src/tests/runtime/test_managed_query_service.py

from __future__ import annotations

import copy
import hashlib
import hmac
import json
import os
import pickle
import sqlite3
from collections.abc import Callable
from concurrent.futures import ThreadPoolExecutor
from contextlib import nullcontext
from dataclasses import dataclass, field, replace
from datetime import UTC, datetime
from pathlib import Path
from threading import Barrier
from types import SimpleNamespace

import networkx as nx
import pytest

import ctx.runtime as ctx_runtime
import ctx.runtime.managed_query_service as managed_query_service_module
from ctx.core.graph.graph_store import build_graph_store
from ctx.core.install_consent_broker_store import (
    ConsentBrokerDecisionRejected,
    ConsentBrokerExpired,
    HumanDecisionVerifier,
    SQLiteInstallConsentBrokerStore,
    SignedHumanDecisionAssertion,
)
from ctx.core.install_policy_store import persist_install_policy
from ctx.core.resolve.engine_candidates import IndexedGraphCandidateSource
from ctx.engine.benefit import BenefitCandidate, EvidenceSummary, NetBenefitPolicy, ResourceCosts
from ctx.engine.content import MaterialDescriptor, MaterialIdentity
from ctx.engine.engine import CtxEngine
from ctx.engine.installation import (
    InstallConsentPolicy,
    InstallExecutionBinding,
    InstallPlanDescriptor,
    InstallPlanningBundle,
    PreparedInstallPlan,
)
from ctx.engine.planning_v3 import CapabilityPlanSelectionV3
from ctx.engine.planner import CapabilityCandidate, WorkObservation
from ctx.engine.protocol import (
    INSTALL_RECEIPT_SCHEMA_V3,
    MATERIAL_RECEIPT_SCHEMA_V3,
    EngineEvent,
    HostAction,
    ScopeRef,
    Transition,
)
from ctx.engine.replay import ObservationReference, ReplayInput, StructuredSurrogate
from ctx.engine.state import CommittedPlanV3, EngineState
from ctx.engine.store import SQLiteEngineStore, StreamId
from ctx.runtime.composition import (
    EngineComposition,
    open_engine_composition,
    open_managed_engine_composition,
)
from ctx.runtime.managed_artifact_registry import (
    ManagedArtifactHandle,
    ManagedArtifactRegistry,
    open_managed_artifact_registry,
)
from ctx.runtime.managed_query_service import (
    ManagedConsentResolutionResult,
    ManagedConsentChallengeProjection,
    ManagedDesiredSetBusyError,
    ManagedDesiredSetConflictError,
    ManagedDesiredSetRequest,
    ManagedDesiredSetResult,
    ManagedDesiredSetSupersededError,
    ManagedQueryHeadDriftError,
    ManagedQueryInput,
    ManagedQueryRequest,
    ManagedQueryService,
    ManagedQueryServiceError,
    ManagedQueryServiceResult,
    ManagedQuerySupersededError,
    open_managed_query_service,
)
from ctx.runtime.install_consent_broker import InstallConsentBrokerService
from ctx.runtime.install_consent_authenticators import (
    HumanDecisionVerifierRegistration,
    TrustedHumanDecisionVerifierRegistry,
    UnknownHumanDecisionVerifier,
    encode_signed_human_decision_assertion,
)
from ctx.runtime.skill_cas import SkillCasRuntimeConfig
from ctx.runtime.managed_query_store import (
    ManagedQueryRecord,
    ManagedQueryStore,
    ManagedQueryStoreConflict,
    open_managed_query_store,
)


NOW = "2026-08-03T12:00:00Z"
CATALOG_NAMESPACE_DIGEST = hashlib.sha256(b"managed-service-catalog").hexdigest()
STORE_KEY = hashlib.sha256(b"managed-service-store-key").digest()
WORKSPACE_DIGEST = hashlib.sha256(b"managed-service-workspace").hexdigest()
RELEASE_ROOT_DIGEST = hashlib.sha256(b"managed-service-release-root").hexdigest()
CONSENT_AUDIENCE = "ctx-managed-query"
INSTALLABLE_SKILL_BODY = (
    "---\nname: installable\ndescription: managed service install fixture\n---\n"
    "Use the managed service.\n"
)
CONSENT_TEST_SECRET = b"managed-query-consent-test-key"


class _ConsentTestVerifier(HumanDecisionVerifier):
    def verify_signed_assertion(
        self,
        assertion: SignedHumanDecisionAssertion,
        *,
        signing_bytes: bytes,
    ) -> bool:
        return hmac.compare_digest(
            assertion.proof,
            hmac.digest(CONSENT_TEST_SECRET, signing_bytes, "sha256"),
        )


def test_runtime_package_exports_managed_desired_set_contract() -> None:
    assert ctx_runtime.ManagedDesiredSetRequest is ManagedDesiredSetRequest
    assert ctx_runtime.ManagedDesiredSetResult is ManagedDesiredSetResult
    assert ctx_runtime.ManagedDesiredSetBusyError is ManagedDesiredSetBusyError
    assert ctx_runtime.ManagedDesiredSetConflictError is ManagedDesiredSetConflictError
    assert ctx_runtime.ManagedDesiredSetSupersededError is ManagedDesiredSetSupersededError
    assert ctx_runtime.ManagedConsentResolutionResult is ManagedConsentResolutionResult
    assert "ManagedConsentResolutionResult" in managed_query_service_module.__all__


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


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


@dataclass
class _Facts:
    benefit_facts_snapshot_digest: str = field(
        default_factory=lambda: _digest("managed-service-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 _MaterialPort:
    material_snapshot_digest: str = field(
        default_factory=lambda: _digest("managed-service-materials")
    )

    def describe(self, capability_id: str, kind: str) -> MaterialDescriptor:
        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,
        )

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


@dataclass
class _InstallPort:
    installation_snapshot_digest: str = field(
        default_factory=lambda: _digest("managed-service-installs")
    )
    bundles: dict[str, InstallPlanningBundle] = field(default_factory=dict)

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

    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 prepare(self, *_args: object, **_kwargs: object) -> PreparedInstallPlan:
        raise AssertionError("service planning must not prepare installation")


@dataclass
class _InputAuthority:
    values: dict[str, ManagedQueryInput]
    calls: list[str] = field(default_factory=list)

    def resolve(self, current_work_ref: str) -> ManagedQueryInput:
        self.calls.append(current_work_ref)
        try:
            return self.values[current_work_ref]
        except KeyError:
            raise LookupError("current-work reference is unavailable") from None


@dataclass
class _BodySource:
    load_calls: int = 0
    fail_loads_remaining: int = 0

    def load(self, *_args: object, **_kwargs: object) -> str:
        self.load_calls += 1
        if self.fail_loads_remaining:
            self.fail_loads_remaining -= 1
            raise RuntimeError("simulated trusted body-source failure")
        return INSTALLABLE_SKILL_BODY


@dataclass(frozen=True)
class _Setup:
    registry: ManagedArtifactRegistry
    artifact: ManagedArtifactHandle
    store: ManagedQueryStore
    store_path: Path
    journal_path: Path
    audit_path: Path
    policy_root: Path
    facts: _Facts
    policy: NetBenefitPolicy
    materials: _MaterialPort
    installs: _InstallPort
    inputs: _InputAuthority
    body_source: _BodySource
    skill_runtime: SkillCasRuntimeConfig
    consent_broker: InstallConsentBrokerService
    consent_store_path: Path
    verifier_registry: TrustedHumanDecisionVerifierRegistry
    managed_input: ManagedQueryInput
    service: ManagedQueryService
    clock: Callable[[], datetime]


def _surrogate(requested_limit: int) -> 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,
        },
    )


def _install_bundle(
    capability_id: str,
    snapshot_digest: str,
    *,
    permission_expansion: bool = False,
    credential_requirement: bool = False,
) -> InstallPlanningBundle:
    kind = capability_id.split(":", 1)[0]
    material = MaterialIdentity.create(
        capability_id=capability_id,
        kind=kind,
        content_sha256=hashlib.sha256(INSTALLABLE_SKILL_BODY.encode("utf-8")).hexdigest(),
        content_bytes=len(INSTALLABLE_SKILL_BODY.encode("utf-8")),
    )
    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,
        permission_expansion=permission_expansion,
        credential_requirement=credential_requirement,
        result_material_identity_digest=material.identity_digest,
    )
    return InstallPlanningBundle(descriptor=descriptor, result_material=material)


def _events(artifact: ManagedArtifactHandle) -> tuple[EngineEvent, EngineEvent]:
    scope = _scope()
    common = {
        "scope": scope,
        "occurred_at": NOW,
        "correlation_id": "plan-initial",
        "engine_version": "ctx-engine-v1",
        "planner_version": artifact.planning_schema_version,
        "policy_version": "policy-v1",
        "host_descriptor_digest": _digest("host-neutral-managing"),
        "catalog_snapshot_digest": artifact.planning_environment_digest,
        "semantic_model_digest": _digest("semantic-model-disabled"),
        "semantic_index_digest": _digest("semantic-index-disabled"),
        "work_signature": _digest("managed-service-work"),
        "random_seed": 0,
    }
    started = EngineEvent(
        event_id="event-session-started",
        kind="SessionStarted",
        expected_revision=0,
        payload={"host_level": "managing"},
        causation_id="cause-session",
        **common,  # type: ignore[arg-type]
    )
    reference = artifact.observation_reference
    intent = EngineEvent(
        event_id="event-intent-observed",
        kind="IntentObserved",
        expected_revision=1,
        payload={
            "observation_ref": {
                "provider_id": reference.provider_id,
                "opaque_id": reference.opaque_id,
                "content_digest": reference.content_digest,
            }
        },
        causation_id=started.event_id,
        **common,  # type: ignore[arg-type]
    )
    return started, intent


def _setup(
    tmp_path: Path,
    *,
    requested_limit: int = 5,
    installable: bool = False,
    installable_count: int = 1,
    permission_expansion: bool = False,
    credential_requirement: bool = False,
    trusted_now: datetime = datetime(2026, 8, 3, 12, 0, tzinfo=UTC),
    trusted_clock: Callable[[], datetime] | None = None,
) -> _Setup:
    tmp_path.mkdir(parents=True, exist_ok=True)
    tmp_path.chmod(0o700)
    capabilities = (
        tuple(
            "skill:installable" if index == 0 else f"skill:installable-{index + 1}"
            for index in range(installable_count)
        )
        if installable
        else (
            "agent:reviewer",
            "harness:python-runner",
            "mcp-server:docs",
            "skill:lint",
            "skill:test",
            "skill:types",
        )
    )
    graph = nx.Graph()
    for capability_id in capabilities:
        kind, name = capability_id.split(":", 1)
        graph.add_node(capability_id, label=name, type=kind, tags=["python"])
    graph_path = tmp_path / "graph.sqlite3"
    build_graph_store(graph_path, graph)
    graph_path.chmod(0o400)
    graph_digest = hashlib.sha256(graph_path.read_bytes()).hexdigest()
    facts = _Facts()
    policy = NetBenefitPolicy(
        calibration_digest=_digest("managed-service-calibration"),
        minimum_relevance_ppm=1,
    )
    materials = _MaterialPort()
    installs = _InstallPort()
    if installable:
        for capability_id in capabilities:
            installs.bundles[capability_id] = _install_bundle(
                capability_id,
                installs.installation_snapshot_digest,
                permission_expansion=permission_expansion,
                credential_requirement=credential_requirement,
            )
    surrogate = _surrogate(requested_limit)
    with IndexedGraphCandidateSource(
        graph_path,
        graph_digest,
        material_port=materials,  # type: ignore[arg-type]
        install_plan_port=installs,
    ) as source:
        retrieval_digest = source.catalog_snapshot_digest

    def normalizer(
        _reference: ObservationReference,
        _state: EngineState | None,
    ) -> StructuredSurrogate:
        return surrogate

    with open_engine_composition(
        graph_artifact_path=graph_path,
        graph_artifact_sha256=graph_digest,
        journal_path=tmp_path / "identity-journal.sqlite3",
        observation_normalizer=normalizer,
        benefit_facts_port=facts,
        net_benefit_policy=policy,
        catalog_namespace_digest=CATALOG_NAMESPACE_DIGEST,
        benefit_audit_path=tmp_path / "identity-audit.sqlite3",
        material_port=materials,  # type: ignore[arg-type]
        install_bundle_port=installs,
        planner_version="ctx-managed-service-planner-v3",
    ) as identity:
        planning_environment_digest = identity.catalog_snapshot_digest

    registry = open_managed_artifact_registry(root=tmp_path / "registry")
    artifact = registry.ingest_graph_store(
        graph_store_path=graph_path,
        expected_graph_artifact_digest=graph_digest,
        planning_environment_digest=planning_environment_digest,
        catalog_namespace_digest=CATALOG_NAMESPACE_DIGEST,
        catalog_retrieval_digest=retrieval_digest,
        benefit_facts_snapshot_digest=facts.benefit_facts_snapshot_digest,
        benefit_policy_snapshot_digest=policy.policy_digest,
        material_snapshot_digest=materials.material_snapshot_digest,
        installation_snapshot_digest=installs.installation_snapshot_digest,
        observation_surrogate=surrogate,
        planning_schema_version="ctx-managed-service-planner-v3",
    )
    started, intent = _events(artifact)
    managed_input = ManagedQueryInput(
        artifact=artifact,
        session_started=started,
        decision_event=intent,
    )
    inputs = _InputAuthority(values={"work-one": managed_input})
    store_path = (tmp_path / "private" / "queries.sqlite3").absolute()
    store = open_managed_query_store(path=store_path, installation_hmac_key=STORE_KEY)
    journal_path = (tmp_path / "private" / "journal.sqlite3").absolute()
    audit_path = (tmp_path / "private" / "audit.sqlite3").absolute()
    policy_root = (tmp_path / "private" / "install-policy").absolute()
    consent_store_path = (tmp_path / "private" / "consent.sqlite3").absolute()
    clock = trusted_clock or (lambda: trusted_now)
    consent_broker = InstallConsentBrokerService(
        store=SQLiteInstallConsentBrokerStore(
            consent_store_path,
            audience=CONSENT_AUDIENCE,
        ),
        verifier=None,
        workspace_identity_digest=WORKSPACE_DIGEST,
        release_root_digest=RELEASE_ROOT_DIGEST,
        trusted_utc_now=clock,
    )
    verifier_registry = TrustedHumanDecisionVerifierRegistry(
        (
            HumanDecisionVerifierRegistration(
                audience=CONSENT_AUDIENCE,
                authenticator_id="managed-test-authenticator",
                principal_digest=_digest("managed-test-principal"),
                verifier=_ConsentTestVerifier(),
            ),
        )
    )
    skill_root = tmp_path / "private" / "skills"
    skill_root.mkdir(mode=0o700)
    body_source = _BodySource()
    skill_runtime = SkillCasRuntimeConfig(
        skill_store_root=skill_root,
        body_source=body_source,
        installer_id="ctx-skill-installer-v1",
        host_identity_digest=_digest("managed-service-host"),
    )
    service = open_managed_query_service(
        registry=registry,
        query_store=store,
        journal_path=journal_path,
        benefit_audit_path=audit_path,
        benefit_facts_port=facts,
        net_benefit_policy=policy,
        material_port=materials,  # type: ignore[arg-type]
        install_bundle_port=installs,
        input_authority=inputs,
        consent_broker=consent_broker,
        policy_store_root=policy_root,
        trusted_utc_now=clock,
        verifier_registry=verifier_registry,
        skill_cas_runtime=skill_runtime,
    )
    return _Setup(
        registry=registry,
        artifact=artifact,
        store=store,
        store_path=store_path,
        journal_path=journal_path,
        audit_path=audit_path,
        policy_root=policy_root,
        facts=facts,
        policy=policy,
        materials=materials,
        installs=installs,
        inputs=inputs,
        body_source=body_source,
        skill_runtime=skill_runtime,
        consent_broker=consent_broker,
        consent_store_path=consent_store_path,
        verifier_registry=verifier_registry,
        managed_input=managed_input,
        service=service,
        clock=clock,
    )


def _register(setup: _Setup, logical_query_id: str) -> ManagedQueryRecord:
    value = setup.managed_input
    return setup.store.register(
        logical_query_id=logical_query_id,
        session_started=value.session_started,
        decision_event=value.decision_event,
        artifact_manifest_digest=value.artifact.manifest_digest,
        planning_environment_digest=value.artifact.planning_environment_digest,
    )


def _open_peer_service(setup: _Setup) -> ManagedQueryService:
    return open_managed_query_service(
        registry=setup.registry,
        query_store=setup.store,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        input_authority=setup.inputs,
        consent_broker=setup.consent_broker,
        policy_store_root=setup.policy_root,
        trusted_utc_now=lambda: datetime(2026, 8, 3, 12, 0, tzinfo=UTC),
        verifier_registry=setup.verifier_registry,
        skill_cas_runtime=setup.skill_runtime,
    )


def _prepare_public_consent(
    setup: _Setup,
    *,
    label: str = "signed-consent",
) -> ManagedDesiredSetResult:
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest(f"{label}:query"),
            current_work_ref="work-one",
        )
    )
    capability_id = prepared.prepared.selections[0].capability_id
    result = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest(f"{label}:desired"),
            capability_ids=(capability_id,),
        )
    )
    assert result.status == "consent-required"
    assert result.challenge is not None
    return result


def _consent_assertion_payload(
    challenge: ManagedConsentChallengeProjection,
    *,
    decision: str = "granted",
    nonce: str = "managed-consent-nonce-1",
    principal_digest: str | None = None,
    authenticator_id: str = "managed-test-authenticator",
    audience: str = CONSENT_AUDIENCE,
    issued_at: str = "2026-08-03T12:00:00Z",
    expires_at: str = "2026-08-03T12:30:00Z",
    valid_proof: bool = True,
) -> bytes:
    unsigned = SignedHumanDecisionAssertion(
        challenge_digest=challenge.challenge_digest,
        decision=decision,
        principal_digest=principal_digest or _digest("managed-test-principal"),
        authenticator_id=authenticator_id,
        audience=audience,
        nonce=nonce,
        issued_at=issued_at,
        expires_at=expires_at,
        proof=b"unsigned",
    )
    assertion = replace(
        unsigned,
        proof=(
            hmac.digest(CONSENT_TEST_SECRET, unsigned.signing_bytes(), "sha256")
            if valid_proof
            else b"invalid-proof"
        ),
    )
    return encode_signed_human_decision_assertion(assertion)


def _commit_pending_consent(
    setup: _Setup,
    *,
    logical_query_id: str = "pending-consent-query",
) -> tuple[ManagedQueryServiceResult, HostAction]:
    initial = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest(logical_query_id),
            current_work_ref="work-one",
        )
    )
    original = setup.managed_input.decision_event
    with open_managed_engine_composition(
        registry=setup.registry,
        artifact=setup.artifact,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        policy_store_root=setup.policy_root,
        skill_cas_runtime=setup.skill_runtime,
    ) as composition:
        snapshot = composition.snapshot(original.scope)
        assert snapshot.state is not None
        committed = snapshot.state.committed_plan
        assert isinstance(committed, CommittedPlanV3)
        capability = committed.capabilities[0]
        desired = composition.process(
            replace(
                original,
                event_id="event-managed-consent-desired",
                kind="ReassessmentRequested",
                expected_revision=2,
                payload={
                    "owner_id": "owner-managed-consent",
                    "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-managed-consent",
                        }
                    ],
                },
            )
        )
    requests = tuple(action for action in desired.actions if action.kind == "RequestConsent")
    assert len(requests) == 1
    return initial, requests[0]


def _commit_consent_decision(setup: _Setup, request: HostAction) -> None:
    original = setup.managed_input.decision_event
    with open_managed_engine_composition(
        registry=setup.registry,
        artifact=setup.artifact,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        policy_store_root=setup.policy_root,
        interactive_install_decision_guard=lambda _reservation: nullcontext(),
        skill_cas_runtime=setup.skill_runtime,
        trusted_utc_now=setup.clock,
    ) as composition:
        composition.process(
            replace(
                original,
                event_id="event-managed-consent-race-decision",
                kind="UserDecision",
                expected_revision=3,
                occurred_at="2026-08-03T12:01:00Z",
                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"
                    ],
                },
            )
        )


def test_service_sets_an_empty_desired_subset_without_replanning(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-empty-query"),
            current_work_ref="work-one",
        )
    )
    calls_before = tuple(setup.facts.calls)
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-empty-choice"),
        capability_ids=(),
    )

    result = setup.service.set_desired(request)

    assert type(result) is ManagedDesiredSetResult
    assert result.query_ref == prepared.query_ref
    assert result.logical_choice_id == request.logical_choice_id
    assert result.capability_ids == ()
    assert result.deferred_capability_ids == ()
    assert result.status == "reconciled"
    assert result.reason_code is None
    assert result.plan_id == prepared.prepared.plan_id
    assert result.decision_digest == prepared.prepared.decision_digest
    assert result.journal_revision == 3
    assert len(result.journal_record_digest) == 64
    assert result.actions == ()
    assert result.challenge is None
    assert tuple(setup.facts.calls) == calls_before
    stored = setup.store.load_latest_desired_set(prepared.query_ref)
    assert stored.committed
    assert stored.desired_set_ref == result.desired_set_ref
    for operation in (copy.copy, copy.deepcopy, pickle.dumps):
        with pytest.raises(TypeError):
            operation(result)
        with pytest.raises(TypeError):
            operation(request)


def test_service_sets_an_install_desired_subset_and_requires_consent(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-install-query"),
            current_work_ref="work-one",
        )
    )
    calls_before = tuple(setup.facts.calls)
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-install-choice"),
        capability_ids=("skill:installable",),
    )

    first = setup.service.set_desired(request)
    repeated = setup.service.set_desired(request)

    assert first.status == repeated.status == "consent-required"
    assert first.reason_code is repeated.reason_code is None
    assert first.capability_ids == repeated.capability_ids == ("skill:installable",)
    assert first.deferred_capability_ids == repeated.deferred_capability_ids == ()
    assert first.desired_set_ref == repeated.desired_set_ref
    assert first.journal_revision == repeated.journal_revision == 3
    assert first.journal_record_digest == repeated.journal_record_digest
    assert [action.kind for action in first.actions] == ["RequestConsent"]
    assert first.actions == repeated.actions
    assert first.challenge == repeated.challenge
    assert type(first.challenge) is ManagedConsentChallengeProjection
    assert tuple(setup.facts.calls) == calls_before
    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_desired_sets").fetchone() == (1,)
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (3,)


def test_desired_retry_refuses_interactive_effect_without_signed_execution_path(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-pending-effect-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-pending-effect-choice"),
        capability_ids=("skill:installable",),
    )
    desired = setup.service.set_desired(request)
    assert desired.status == "consent-required"
    original = setup.managed_input.decision_event

    with open_managed_engine_composition(
        registry=setup.registry,
        artifact=setup.artifact,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        policy_store_root=setup.policy_root,
        interactive_install_decision_guard=lambda _reservation: nullcontext(),
        skill_cas_runtime=setup.skill_runtime,
        trusted_utc_now=setup.clock,
    ) as composition:
        snapshot = composition.snapshot(original.scope)
        assert snapshot.state is not None
        pending = snapshot.state.pending_consents[0]
        consent_request = setup.service._current_consent_request(  # noqa: SLF001
            scope=original.scope,
            revision=snapshot.revision,
            consent_id=pending.consent_id,
            install_action=pending.install_action,
        )
        granted = composition.process(
            replace(
                original,
                event_id="event-desired-pending-effect-granted",
                kind="UserDecision",
                expected_revision=snapshot.revision,
                payload={
                    "consent_id": consent_request.consent_id,
                    "decision": "granted",
                    "decision_basis": "interactive",
                    "policy_snapshot_digest": InstallConsentPolicy.safe_default().policy_digest,
                    "requested_action_id": consent_request.payload["requested_action_id"],
                    "requested_action_kind": consent_request.payload["requested_action_kind"],
                    "requested_action_content_digest": consent_request.payload[
                        "requested_action_content_digest"
                    ],
                    "requested_action_precondition_revision": consent_request.payload[
                        "requested_action_precondition_revision"
                    ],
                },
            )
        )
        assert [action.kind for action in granted.actions] == ["InstallCapability"]
        observed = composition.process(
            replace(
                original,
                event_id="event-desired-pending-effect-observed",
                kind="ProviderSubmissionObserved",
                expected_revision=granted.to_revision,
                payload={"capabilities": []},
            )
        )
        assert observed.actions == ()
        state = composition.snapshot(original.scope).state
        assert state is not None
        assert [(item.effect, item.action.kind) for item in state.pending_effects] == [
            ("install", "InstallCapability")
        ]

    with pytest.raises(ManagedQueryServiceError, match="interactive install decision"):
        setup.service.set_desired(request)

    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)


@pytest.mark.parametrize(
    "event_kind",
    ["ProviderSubmissionObserved", "ToolCallObserved", "TurnStarting"],
)
def test_actionless_revision_reoffers_consent_and_retry_never_reports_reconciled(
    tmp_path: Path,
    event_kind: str,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest(f"stale-consent-{event_kind}-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest(f"stale-consent-{event_kind}-choice"),
        capability_ids=("skill:installable",),
    )
    initial = setup.service.set_desired(request)
    assert initial.status == "consent-required"
    original = setup.managed_input.decision_event
    payload: dict[str, object]
    if event_kind == "ProviderSubmissionObserved":
        payload = {"capabilities": []}
    elif event_kind == "ToolCallObserved":
        payload = {
            "capability_id": "skill:installable",
            "source_digest": prepared.prepared.selections[0].source_digest,
            "outcome": "failed",
        }
    else:
        payload = {}
    with open_managed_engine_composition(
        registry=setup.registry,
        artifact=setup.artifact,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        policy_store_root=setup.policy_root,
        skill_cas_runtime=setup.skill_runtime,
    ) as composition:
        consumed = composition.process(
            replace(
                original,
                event_id=f"event-stale-consent-{event_kind}",
                kind=event_kind,
                expected_revision=3,
                payload=payload,
            )
        )
        state = composition.snapshot(original.scope).state

    assert tuple(action.kind for action in consumed.actions) == ("RequestConsent",)
    assert state is not None
    assert len(state.pending_consents) == 1

    retried = setup.service.set_desired(request)

    assert retried.status == "consent-required"
    assert retried.reason_code is None
    assert retried.deferred_capability_ids == ()
    assert retried.failed_capability_ids == ()
    assert retried.challenge is not None
    assert tuple(action.kind for action in retried.actions) == ("RequestConsent",)


def test_desired_request_canonicalizes_committed_plan_order_and_manual_deferral(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=3)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-manual-query"),
            current_work_ref="work-one",
        )
    )
    plan_order = tuple(item.capability_id for item in prepared.prepared.selections)
    requested = tuple(reversed(plan_order[:2]))

    result = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-manual-choice"),
            capability_ids=requested,
        )
    )

    assert result.capability_ids == plan_order[:2]
    assert result.deferred_capability_ids == plan_order[:2]
    assert result.status == "manual-deferred"
    assert result.reason_code == "manual-capability-requires-user-action"
    assert result.challenge is None


@pytest.mark.parametrize(
    ("capability_ids", "error_type", "message"),
    [
        (["skill:test"], TypeError, "exact tuple"),
        (("skill:test", "skill:test"), ValueError, "unique"),
        (
            tuple(f"skill:test-{index}" for index in range(6)),
            ValueError,
            "more than five",
        ),
    ],
)
def test_desired_request_rejects_unsafe_subsets(
    capability_ids: object,
    error_type: type[Exception],
    message: str,
) -> None:
    with pytest.raises(error_type, match=message):
        ManagedDesiredSetRequest(
            query_ref="mqr_" + "a" * 64,
            logical_choice_id=_digest("unsafe-desired-request"),
            capability_ids=capability_ids,  # type: ignore[arg-type]
        )


def test_service_rejects_unknown_desired_capability_before_durable_mutation(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-unknown-query"),
            current_work_ref="work-one",
        )
    )

    with pytest.raises(ManagedQueryServiceError, match="not contained"):
        setup.service.set_desired(
            ManagedDesiredSetRequest(
                query_ref=prepared.query_ref,
                logical_choice_id=_digest("desired-unknown-choice"),
                capability_ids=("skill:not-in-plan",),
            )
        )

    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_desired_sets").fetchone() == (0,)
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (2,)


def test_preapproved_desired_install_executes_once_and_retries_from_receipt(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-auto-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-auto-choice"),
        capability_ids=("skill:installable",),
    )

    first = setup.service.set_desired(request)
    repeated = setup.service.set_desired(request)

    assert first.status == repeated.status == "effect-pending"
    assert first.reason_code is repeated.reason_code is None
    assert first.deferred_capability_ids == repeated.deferred_capability_ids == ()
    assert first.failed_capability_ids == repeated.failed_capability_ids == ()
    assert first.challenge is repeated.challenge is None
    assert first.desired_set_ref == repeated.desired_set_ref
    assert tuple(action.kind for action in first.actions) == ("ActivateCapability",)
    assert repeated.actions == first.actions
    assert setup.body_source.load_calls == 1
    bundle = setup.installs.bundles["skill:installable"]
    installed = setup.skill_runtime.skill_store_root / bundle.result_material.content_sha256
    assert installed.read_text(encoding="utf-8") == INSTALLABLE_SKILL_BODY
    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)
    with sqlite3.connect(setup.journal_path) as connection:
        rows = tuple(
            connection.execute(
                "SELECT event_id, replay_json FROM engine_journal ORDER BY revision"
            ).fetchall()
        )
    assert len(rows) == 5
    assert rows[3][0].startswith("ctx-auto-install:")
    assert ReplayInput.from_json(rows[3][1]).reducer_event.kind == "UserDecision"
    assert ReplayInput.from_json(rows[4][1]).reducer_event.kind == "ActionApplied"


def test_two_services_converge_on_one_preapproved_install_and_receipt(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-auto-concurrent-query"),
            current_work_ref="work-one",
        )
    )
    peer = _open_peer_service(setup)
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-auto-concurrent-choice"),
        capability_ids=("skill:installable",),
    )
    barrier = Barrier(2)

    def attempt(service: ManagedQueryService) -> ManagedDesiredSetResult:
        barrier.wait()
        return service.set_desired(request)

    with ThreadPoolExecutor(max_workers=2) as pool:
        results = tuple(pool.map(attempt, (setup.service, peer)))

    assert results[0].desired_set_ref == results[1].desired_set_ref
    assert results[0].status == results[1].status == "effect-pending"
    assert results[0].actions == results[1].actions
    assert setup.body_source.load_calls == 1
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (5,)
        assert connection.execute(
            "SELECT count(*) FROM engine_install_claim_settlements"
        ).fetchone() == (1,)

    recovered = setup.service.set_desired(request)

    assert recovered.status == "effect-pending"
    assert recovered.failed_capability_ids == ()
    assert setup.body_source.load_calls == 1
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (5,)
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (1,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (1,)
        assert connection.execute(
            "SELECT count(*) FROM engine_install_claim_settlements"
        ).fetchone() == (1,)


def test_preapproved_install_requires_captured_actuator_before_grant(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-auto-no-actuator-query"),
            current_work_ref="work-one",
        )
    )
    without_actuator = open_managed_query_service(
        registry=setup.registry,
        query_store=setup.store,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        input_authority=setup.inputs,
        consent_broker=setup.consent_broker,
        policy_store_root=setup.policy_root,
    )

    with pytest.raises(RuntimeError, match="no physical installation actuator"):
        without_actuator.set_desired(
            ManagedDesiredSetRequest(
                query_ref=prepared.query_ref,
                logical_choice_id=_digest("desired-auto-no-actuator-choice"),
                capability_ids=("skill:installable",),
            )
        )

    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        rows = tuple(
            connection.execute(
                "SELECT replay_json FROM engine_journal ORDER BY revision"
            ).fetchall()
        )
    assert tuple(ReplayInput.from_json(row[0]).reducer_event.kind for row in rows) == (
        "SessionStarted",
        "IntentObserved",
        "ReassessmentRequested",
    )


def test_preapproved_policy_race_fails_before_grant_and_execution(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-auto-policy-race-query"),
            current_work_ref="work-one",
        )
    )
    original = EngineComposition.resolve_install_execution_binding
    changed = False

    def change_policy_after_binding(
        composition: EngineComposition,
        action: HostAction,
        selection: CapabilityPlanSelectionV3,
    ) -> InstallExecutionBinding:
        nonlocal changed
        binding = original(composition, action, selection)
        if not changed:
            changed = True
            persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
        return binding

    monkeypatch.setattr(
        EngineComposition,
        "resolve_install_execution_binding",
        change_policy_after_binding,
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-auto-policy-race-choice"),
        capability_ids=("skill:installable",),
    )

    with pytest.raises(RuntimeError, match="policy"):
        setup.service.set_desired(request)

    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (3,)


def test_indeterminate_preapproved_install_is_explicit_then_settles_failed_once(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    setup.body_source.fail_loads_remaining = 1
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-auto-indeterminate-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-auto-indeterminate-choice"),
        capability_ids=("skill:installable",),
    )

    indeterminate = setup.service.set_desired(request)
    failed = setup.service.set_desired(request)
    repeated = setup.service.set_desired(request)

    assert indeterminate.status == "lifecycle-deferred"
    assert indeterminate.reason_code == "automatic-install-indeterminate"
    assert indeterminate.deferred_capability_ids == ("skill:installable",)
    assert indeterminate.failed_capability_ids == ()
    assert failed.status == repeated.status == "lifecycle-deferred"
    assert failed.reason_code == repeated.reason_code == "automatic-install-failed"
    assert (
        failed.deferred_capability_ids == repeated.deferred_capability_ids == ("skill:installable",)
    )
    assert failed.failed_capability_ids == repeated.failed_capability_ids == ("skill:installable",)
    assert setup.body_source.load_calls == 1
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (1,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (1,)
        assert connection.execute(
            "SELECT count(*) FROM engine_install_claim_settlements"
        ).fetchone() == (1,)


def test_failed_auto_install_progresses_to_next_capability_without_losing_failure(
    tmp_path: Path,
) -> None:
    setup = _setup(
        tmp_path,
        requested_limit=2,
        installable=True,
        installable_count=2,
    )
    setup.body_source.fail_loads_remaining = 1
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-auto-mixed-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-auto-mixed-choice"),
        capability_ids=("skill:installable", "skill:installable-2"),
    )

    first = setup.service.set_desired(request)
    progressed = setup.service.set_desired(request)
    repeated = setup.service.set_desired(request)

    assert first.reason_code == "automatic-install-indeterminate"
    assert progressed.status == repeated.status == "effect-pending"
    assert progressed.deferred_capability_ids == repeated.deferred_capability_ids == ()
    assert (
        progressed.failed_capability_ids == repeated.failed_capability_ids == ("skill:installable",)
    )
    assert tuple(action.kind for action in progressed.actions) == ("ActivateCapability",)
    assert setup.body_source.load_calls == 2
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (2,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (2,)
        assert connection.execute(
            "SELECT count(*) FROM engine_install_claim_settlements"
        ).fetchone() == (2,)


def test_preapproved_install_recovers_after_crash_following_decision(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("auto-crash-after-decision-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("auto-crash-after-decision-choice"),
        capability_ids=("skill:installable",),
    )
    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            EngineComposition,
            "execute_install",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated crash after automatic decision")
            ),
        )
        with pytest.raises(RuntimeError, match="after automatic decision"):
            setup.service.set_desired(request)

    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (4,)
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)
    # The exact grant is already journaled. A later policy change cannot revoke
    # its pending physical action or force a second consent decision.
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)

    recovered = setup.service.set_desired(request)

    assert recovered.status == "effect-pending"
    assert recovered.failed_capability_ids == ()
    assert setup.body_source.load_calls == 1


def test_preapproved_install_rejects_changed_target_after_committed_decision(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("auto-changed-target-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("auto-changed-target-choice"),
        capability_ids=("skill:installable",),
    )
    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            EngineComposition,
            "execute_install",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated crash after bound automatic decision")
            ),
        )
        with pytest.raises(RuntimeError, match="after bound automatic decision"):
            setup.service.set_desired(request)

    changed_root = tmp_path / "private" / "changed-skills"
    changed_root.mkdir(mode=0o700)
    changed_source = _BodySource()
    changed_runtime = SkillCasRuntimeConfig(
        skill_store_root=changed_root,
        body_source=changed_source,
        installer_id="ctx-skill-installer-v1",
        host_identity_digest=_digest("managed-service-host"),
    )
    reopened = open_managed_query_service(
        registry=setup.registry,
        query_store=setup.store,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        input_authority=setup.inputs,
        consent_broker=setup.consent_broker,
        policy_store_root=setup.policy_root,
        trusted_utc_now=lambda: datetime(2026, 8, 3, 12, 0, tzinfo=UTC),
        skill_cas_runtime=changed_runtime,
    )

    with pytest.raises(ManagedQueryServiceError, match="captured actuator"):
        reopened.set_desired(request)

    assert setup.body_source.load_calls == changed_source.load_calls == 0
    assert tuple(setup.skill_runtime.skill_store_root.iterdir()) == ()
    assert tuple(changed_root.iterdir()) == ()
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (0,)


def test_preapproved_install_never_reapplies_after_crash_following_claim(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("auto-crash-after-claim-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("auto-crash-after-claim-choice"),
        capability_ids=("skill:installable",),
    )
    original = CtxEngine.authorize_install

    def crash_after_claim(engine: CtxEngine, *args: object, **kwargs: object) -> None:
        original(engine, *args, **kwargs)  # type: ignore[arg-type]
        raise RuntimeError("simulated crash after durable install claim")

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(CtxEngine, "authorize_install", crash_after_claim)
        with pytest.raises(RuntimeError, match="after durable install claim"):
            setup.service.set_desired(request)

    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (1,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (0,)

    recovered = setup.service.set_desired(request)

    assert recovered.status == "lifecycle-deferred"
    assert recovered.reason_code == "automatic-install-failed"
    assert recovered.failed_capability_ids == ("skill:installable",)
    assert setup.body_source.load_calls == 0


def test_preapproved_install_expired_before_claim_retires_once_and_next_choice_progresses(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    current = [datetime(2026, 8, 3, 12, 0, tzinfo=UTC)]
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        trusted_clock=lambda: current[0],
    )
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("auto-expired-before-claim-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("auto-expired-before-claim-choice"),
        capability_ids=("skill:installable",),
    )
    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            EngineComposition,
            "execute_install",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated automatic crash before install claim")
            ),
        )
        with pytest.raises(RuntimeError, match="before install claim"):
            setup.service.set_desired(request)

    current[0] = datetime(2026, 8, 3, 14, 0, tzinfo=UTC)
    retired = setup.service.set_desired(request)
    repeated = setup.service.set_desired(request)

    assert retired.journal_revision == repeated.journal_revision
    assert retired.journal_record_digest == repeated.journal_record_digest
    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (0,)
    expiry_events = tuple(
        record
        for record in SQLiteEngineStore(setup.journal_path).records(StreamId.from_scope(_scope()))
        if ReplayInput.from_json(record.replay_json).reducer_event.kind == "ActionExpired"
    )
    assert len(expiry_events) == 1

    progressed = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("auto-expired-before-claim-next-choice"),
            capability_ids=("skill:installable",),
            expected_previous_desired_set_ref=retired.desired_set_ref,
        )
    )
    assert progressed.reason_code != "automatic-install-failed"
    assert setup.body_source.load_calls == 1
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (1,)


def test_preapproved_install_recovers_after_crash_following_outcome(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("auto-crash-after-outcome-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("auto-crash-after-outcome-choice"),
        capability_ids=("skill:installable",),
    )
    original = CtxEngine._record_install_outcome  # noqa: SLF001

    def crash_after_outcome(engine: CtxEngine, *args: object, **kwargs: object) -> object:
        original(engine, *args, **kwargs)  # type: ignore[arg-type]
        raise RuntimeError("simulated crash after durable install outcome")

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(CtxEngine, "_record_install_outcome", crash_after_outcome)
        with pytest.raises(RuntimeError, match="after durable install outcome"):
            setup.service.set_desired(request)

    assert setup.body_source.load_calls == 1
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (1,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (1,)
        assert connection.execute(
            "SELECT count(*) FROM engine_install_claim_settlements"
        ).fetchone() == (0,)

    recovered = setup.service.set_desired(request)

    assert recovered.status == "effect-pending"
    assert recovered.failed_capability_ids == ()
    assert setup.body_source.load_calls == 1


def test_preapproved_install_recovers_after_crash_following_receipt(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("auto-crash-after-receipt-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("auto-crash-after-receipt-choice"),
        capability_ids=("skill:installable",),
    )
    original = EngineComposition.execute_install

    def crash_after_receipt(
        composition: EngineComposition,
        *args: object,
        **kwargs: object,
    ) -> object:
        original(composition, *args, **kwargs)  # type: ignore[arg-type]
        raise RuntimeError("simulated crash after durable install receipt")

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(EngineComposition, "execute_install", crash_after_receipt)
        with pytest.raises(RuntimeError, match="after durable install receipt"):
            setup.service.set_desired(request)

    assert setup.body_source.load_calls == 1
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (5,)


def test_desired_result_factory_enforces_canonical_bounded_outcome_subsets(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=2)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-result-invariant-query"),
            current_work_ref="work-one",
        )
    )
    capability_ids = tuple(selection.capability_id for selection in prepared.prepared.selections)
    result = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-result-invariant-choice"),
            capability_ids=capability_ids,
        )
    )
    record = setup.store.load_latest_desired_set(prepared.query_ref)
    token = managed_query_service_module._DESIRED_RESULT_FACTORY_TOKEN  # noqa: SLF001

    with pytest.raises(ManagedQueryServiceError, match="deferred subset"):
        ManagedDesiredSetResult._create(  # noqa: SLF001
            factory_token=token,
            record=record,
            deferred_capability_ids=tuple(reversed(capability_ids)),
            failed_capability_ids=(),
            status="manual-deferred",
            reason_code="manual-capability-requires-user-action",
            actions=result.actions,
            challenge=None,
        )
    with pytest.raises(ManagedQueryServiceError, match="failed subset"):
        ManagedDesiredSetResult._create(  # noqa: SLF001
            factory_token=token,
            record=record,
            deferred_capability_ids=(),
            failed_capability_ids=(capability_ids[0],),
            status="reconciled",
            reason_code=None,
            actions=(),
            challenge=None,
        )
    with pytest.raises(ManagedQueryServiceError, match="failed subset"):
        ManagedDesiredSetResult._create(  # noqa: SLF001
            factory_token=token,
            record=record,
            deferred_capability_ids=capability_ids,
            failed_capability_ids=(capability_ids[0], capability_ids[0]),
            status="manual-deferred",
            reason_code="manual-capability-requires-user-action",
            actions=result.actions,
            challenge=None,
        )
    with pytest.raises(ManagedQueryServiceError, match="deferred subset"):
        ManagedDesiredSetResult._create(  # noqa: SLF001
            factory_token=token,
            record=record,
            deferred_capability_ids=capability_ids,
            failed_capability_ids=(),
            status="effect-pending",
            reason_code=None,
            actions=result.actions,
            challenge=None,
        )


def test_desired_result_factory_requires_challenge_action_correspondence(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-result-challenge-query"),
            current_work_ref="work-one",
        )
    )
    result = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-result-challenge-choice"),
            capability_ids=("skill:installable",),
        )
    )
    assert result.challenge is not None
    record = setup.store.load_latest_desired_set(prepared.query_ref)

    with pytest.raises(ManagedQueryServiceError, match="action summary"):
        ManagedDesiredSetResult._create(  # noqa: SLF001
            factory_token=managed_query_service_module._DESIRED_RESULT_FACTORY_TOKEN,  # noqa: SLF001
            record=record,
            deferred_capability_ids=(),
            failed_capability_ids=(),
            status="consent-required",
            reason_code=None,
            actions=(),
            challenge=result.challenge,
        )


def test_automatic_desired_result_exposes_no_execution_or_content_authority(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-auto-privacy-query"),
            current_work_ref="work-one",
        )
    )

    result = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-auto-privacy-choice"),
            capability_ids=("skill:installable",),
        )
    )

    assert set(result.__slots__) == {
        "actions",
        "capability_ids",
        "challenge",
        "decision_digest",
        "deferred_capability_ids",
        "desired_set_ref",
        "failed_capability_ids",
        "journal_record_digest",
        "journal_revision",
        "logical_choice_id",
        "plan_id",
        "query_ref",
        "reason_code",
        "status",
    }
    assert str(tmp_path) not in repr(result)
    for forbidden in (
        "artifact",
        "body",
        "command",
        "driver",
        "execution_binding",
        "install_action",
        "path",
        "receipt",
        "selection",
        "transition",
    ):
        assert not hasattr(result, forbidden)
    for operation in (copy.copy, copy.deepcopy, pickle.dumps):
        with pytest.raises(TypeError):
            operation(result)


def test_service_accepts_sequential_choices_with_exact_predecessors(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=2)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-sequence-query"),
            current_work_ref="work-one",
        )
    )
    capability_id = prepared.prepared.selections[0].capability_id
    first_request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-sequence-first"),
        capability_ids=(),
    )
    first = setup.service.set_desired(first_request)
    second_request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-sequence-second"),
        capability_ids=(capability_id,),
        expected_previous_desired_set_ref=first.desired_set_ref,
    )
    second = setup.service.set_desired(second_request)
    unloaded = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-sequence-third"),
            capability_ids=(),
            expected_previous_desired_set_ref=second.desired_set_ref,
        )
    )

    assert first.status == unloaded.status == "reconciled"
    assert second.status == "manual-deferred"
    assert first.journal_revision == 3
    assert second.journal_revision == 4
    assert unloaded.journal_revision == 5
    with pytest.raises(ManagedDesiredSetSupersededError):
        setup.service.set_desired(first_request)
    with pytest.raises(ManagedDesiredSetSupersededError):
        setup.service.set_desired(
            ManagedDesiredSetRequest(
                query_ref=prepared.query_ref,
                logical_choice_id=_digest("desired-sequence-stale-fourth"),
                capability_ids=(capability_id,),
                expected_previous_desired_set_ref=first.desired_set_ref,
            )
        )


def test_set_desired_recovers_a_reservation_after_process_crash(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-reserve-crash-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-reserve-crash-choice"),
        capability_ids=(),
    )
    original = EngineComposition.process

    def crash_on_desired(composition: EngineComposition, event: EngineEvent) -> Transition:
        if event.kind == "ReassessmentRequested":
            raise RuntimeError("simulated crash after desired reservation")
        return original(composition, event)

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(EngineComposition, "process", crash_on_desired)
        with pytest.raises(RuntimeError, match="after desired reservation"):
            setup.service.set_desired(request)
    pending = setup.store.load_pending_desired_set(_scope())

    recovered = setup.service.set_desired(request)

    assert recovered.desired_set_ref == pending.desired_set_ref
    assert recovered.status == "reconciled"
    assert setup.store.load_desired_set(pending.desired_set_ref).committed


def test_set_desired_recovers_engine_commit_before_store_mark(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-mark-crash-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-mark-crash-choice"),
        capability_ids=(),
    )

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            ManagedQueryStore,
            "mark_desired_set_committed",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated crash before desired store mark")
            ),
        )
        with pytest.raises(RuntimeError, match="before desired store mark"):
            setup.service.set_desired(request)
    pending = setup.store.load_pending_desired_set(_scope())
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (3,)

    recovered = setup.service.set_desired(request)

    assert recovered.desired_set_ref == pending.desired_set_ref
    assert recovered.journal_revision == 3
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (3,)


def test_set_desired_recovers_after_store_mark_before_result(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-result-crash-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-result-crash-choice"),
        capability_ids=(),
    )

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            ManagedDesiredSetResult,
            "_create",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated crash before desired result")
            ),
        )
        with pytest.raises(RuntimeError, match="before desired result"):
            setup.service.set_desired(request)
    committed = setup.store.load_latest_desired_set(prepared.query_ref)
    assert committed.committed

    recovered = setup.service.set_desired(request)

    assert recovered.desired_set_ref == committed.desired_set_ref
    assert recovered.status == "reconciled"


def test_committed_desired_recovery_marks_before_deferring_policy_drift(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-policy-drift-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-policy-drift-choice"),
        capability_ids=("skill:installable",),
    )
    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            ManagedQueryStore,
            "mark_desired_set_committed",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated crash before policy drift mark")
            ),
        )
        with pytest.raises(RuntimeError, match="before policy drift mark"):
            setup.service.set_desired(request)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )

    recovered = setup.service.set_desired(request)

    assert recovered.status == "lifecycle-deferred"
    assert recovered.reason_code == "install-policy-changed-after-desired-commit"
    assert recovered.deferred_capability_ids == ("skill:installable",)
    assert recovered.challenge is None
    assert setup.store.load_latest_desired_set(prepared.query_ref).committed
    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)


def test_reserved_desired_policy_drift_commits_and_allows_exact_reassessment(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-reserved-policy-drift-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-reserved-policy-drift-choice"),
        capability_ids=("skill:installable",),
    )
    original = EngineComposition.process

    def crash_after_reservation(
        composition: EngineComposition,
        event: EngineEvent,
    ) -> Transition:
        if event.kind == "ReassessmentRequested":
            raise RuntimeError("simulated crash before desired policy commit")
        return original(composition, event)

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(EngineComposition, "process", crash_after_reservation)
        with pytest.raises(RuntimeError, match="before desired policy commit"):
            setup.service.set_desired(request)
    pending = setup.store.load_pending_desired_set(_scope())
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)

    recovered = setup.service.set_desired(request)

    assert recovered.desired_set_ref == pending.desired_set_ref
    assert recovered.status == "lifecycle-deferred"
    assert recovered.reason_code == "install-policy-changed-after-desired-commit"
    assert recovered.deferred_capability_ids == ("skill:installable",)
    assert setup.store.load_latest_desired_set(prepared.query_ref).committed

    reassessed = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-current-policy-choice"),
            capability_ids=("skill:installable",),
            expected_previous_desired_set_ref=recovered.desired_set_ref,
        )
    )

    assert reassessed.status == "consent-required"
    assert type(reassessed.challenge) is ManagedConsentChallengeProjection
    assert reassessed.journal_revision == recovered.journal_revision + 1
    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute(
            "SELECT count(*) FROM managed_desired_sets WHERE journal_revision IS NOT NULL"
        ).fetchone() == (2,)
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (4,)


def test_pending_desired_blocks_a_replacement_plan_before_registration(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-block-plan-query"),
            current_work_ref="work-one",
        )
    )
    original = EngineComposition.process

    def crash_on_desired(composition: EngineComposition, event: EngineEvent) -> Transition:
        if event.kind == "ReassessmentRequested":
            raise RuntimeError("simulated pending desired")
        return original(composition, event)

    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-block-plan-choice"),
        capability_ids=(),
    )
    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(EngineComposition, "process", crash_on_desired)
        with pytest.raises(RuntimeError, match="pending desired"):
            setup.service.set_desired(request)

    started = setup.managed_input.session_started
    development = replace(
        setup.managed_input.decision_event,
        event_id="event-development-blocked-by-desired",
        kind="DevelopmentObserved",
        expected_revision=2,
        correlation_id="plan-after-pending-desired",
        causation_id=setup.managed_input.decision_event.event_id,
    )
    setup.inputs.values["work-after-pending-desired"] = ManagedQueryInput(
        artifact=setup.artifact,
        session_started=started,
        decision_event=development,
    )

    with pytest.raises(ManagedDesiredSetBusyError):
        setup.service.prepare(
            ManagedQueryRequest(
                logical_query_id=_digest("plan-blocked-by-pending-desired"),
                current_work_ref="work-after-pending-desired",
            )
        )

    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_queries").fetchone() == (1,)
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (2,)


def test_two_services_serialize_competing_first_desired_choices(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-two-service-query"),
            current_work_ref="work-one",
        )
    )
    peer = _open_peer_service(setup)
    barrier = Barrier(2)
    requests = (
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-two-service-a"),
            capability_ids=(),
        ),
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-two-service-b"),
            capability_ids=(),
        ),
    )

    def attempt(
        service_and_request: tuple[ManagedQueryService, ManagedDesiredSetRequest],
    ) -> ManagedDesiredSetResult | Exception:
        service, desired_request = service_and_request
        barrier.wait()
        try:
            return service.set_desired(desired_request)
        except Exception as exc:  # noqa: BLE001 - concurrent outcome assertion.
            return exc

    with ThreadPoolExecutor(max_workers=2) as pool:
        outcomes = tuple(pool.map(attempt, zip((setup.service, peer), requests, strict=True)))

    assert sum(type(outcome) is ManagedDesiredSetResult for outcome in outcomes) == 1
    assert sum(type(outcome) is ManagedDesiredSetSupersededError for outcome in outcomes) == 1
    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_desired_sets").fetchone() == (1,)
        assert connection.execute(
            "SELECT count(*) FROM managed_desired_sets WHERE journal_revision IS NOT NULL"
        ).fetchone() == (1,)


def test_two_services_converge_on_the_same_logical_desired_choice(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-two-service-same-query"),
            current_work_ref="work-one",
        )
    )
    peer = _open_peer_service(setup)
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-two-service-same-choice"),
        capability_ids=(),
    )
    barrier = Barrier(2)

    def attempt(service: ManagedQueryService) -> ManagedDesiredSetResult:
        barrier.wait()
        return service.set_desired(request)

    with ThreadPoolExecutor(max_workers=2) as pool:
        results = tuple(pool.map(attempt, (setup.service, peer)))

    assert results[0].desired_set_ref == results[1].desired_set_ref
    assert results[0].journal_record_digest == results[1].journal_record_digest
    assert results[0].actions == results[1].actions
    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_desired_sets").fetchone() == (1,)
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_journal").fetchone() == (3,)


def test_two_services_serialize_replacement_planning_against_desired_choice(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-plan-race-query"),
            current_work_ref="work-one",
        )
    )
    development = replace(
        setup.managed_input.decision_event,
        event_id="event-development-racing-desired",
        kind="DevelopmentObserved",
        expected_revision=2,
        correlation_id="plan-racing-desired",
        causation_id=setup.managed_input.decision_event.event_id,
    )
    setup.inputs.values["work-racing-desired"] = ManagedQueryInput(
        artifact=setup.artifact,
        session_started=setup.managed_input.session_started,
        decision_event=development,
    )
    peer = _open_peer_service(setup)
    barrier = Barrier(2)

    def desired_attempt() -> ManagedDesiredSetResult | Exception:
        barrier.wait()
        try:
            return setup.service.set_desired(
                ManagedDesiredSetRequest(
                    query_ref=prepared.query_ref,
                    logical_choice_id=_digest("desired-plan-race-choice"),
                    capability_ids=(),
                )
            )
        except Exception as exc:  # noqa: BLE001 - concurrent outcome assertion.
            return exc

    def planning_attempt() -> ManagedQueryServiceResult | Exception:
        barrier.wait()
        try:
            return peer.prepare(
                ManagedQueryRequest(
                    logical_query_id=_digest("replacement-plan-racing-desired"),
                    current_work_ref="work-racing-desired",
                )
            )
        except Exception as exc:  # noqa: BLE001 - concurrent outcome assertion.
            return exc

    with ThreadPoolExecutor(max_workers=2) as pool:
        desired_future = pool.submit(desired_attempt)
        planning_future = pool.submit(planning_attempt)
        outcomes = (desired_future.result(), planning_future.result())

    assert sum(not isinstance(outcome, Exception) for outcome in outcomes) == 1
    with sqlite3.connect(setup.store_path) as connection:
        desired_rows = connection.execute(
            "SELECT count(*), count(journal_revision) FROM managed_desired_sets"
        ).fetchone()
    assert desired_rows in {(0, 0), (1, 1)}


def test_desired_install_uses_fresh_trusted_time_and_full_digest_identities(
    tmp_path: Path,
) -> None:
    trusted_now = datetime(2026, 8, 3, 15, 30, tzinfo=UTC)
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        trusted_now=trusted_now,
    )
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-fresh-time-query"),
            current_work_ref="work-one",
        )
    )

    result = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest("desired-fresh-time-choice"),
            capability_ids=("skill:installable",),
        )
    )

    stored = setup.store.load_latest_desired_set(prepared.query_ref)
    row = stored.event.payload["desired_capabilities"][0]
    assert stored.event.occurred_at == "2026-08-03T15:30:00Z"
    assert stored.event.occurred_at != setup.managed_input.decision_event.occurred_at
    assert stored.event.event_id.startswith("ctx-desired:")
    assert len(stored.event.event_id.removeprefix("ctx-desired:")) == 64
    assert len(stored.event.payload["owner_id"].removeprefix("ctx-desired:")) == 64
    assert len(row["lease_id"].removeprefix("ctx-lease:")) == 64
    lease_mapping = {
        "capability_id": row["capability_id"],
        "kind": row["kind"],
        "owner_id": stored.event.payload["owner_id"],
        "schema": "ctx.managed-desired-lease.v1",
        "source_digest": row["source_digest"],
    }
    expected_lease = hashlib.sha256(
        json.dumps(
            lease_mapping,
            allow_nan=False,
            ensure_ascii=True,
            separators=(",", ":"),
            sort_keys=True,
        ).encode("ascii")
    ).hexdigest()
    changed_source_lease = hashlib.sha256(
        json.dumps(
            {**lease_mapping, "source_digest": _digest("changed-catalog-source")},
            allow_nan=False,
            ensure_ascii=True,
            separators=(",", ":"),
            sort_keys=True,
        ).encode("ascii")
    ).hexdigest()
    assert row["lease_id"] == f"ctx-lease:{expected_lease}"
    assert changed_source_lease != expected_lease
    assert result.challenge is not None
    assert result.challenge.expires_at == "2026-08-03T16:30:00Z"


@pytest.mark.parametrize("risk", ["permission", "credential"])
def test_preapproved_install_still_requires_consent_for_sensitive_risk(
    tmp_path: Path,
    risk: str,
) -> None:
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        permission_expansion=risk == "permission",
        credential_requirement=risk == "credential",
    )
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest(f"desired-sensitive-{risk}-query"),
            current_work_ref="work-one",
        )
    )

    result = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=prepared.query_ref,
            logical_choice_id=_digest(f"desired-sensitive-{risk}-choice"),
            capability_ids=("skill:installable",),
        )
    )

    assert result.status == "consent-required"
    assert result.reason_code is None
    assert result.deferred_capability_ids == ()
    assert type(result.challenge) is ManagedConsentChallengeProjection


def test_set_desired_fails_typed_when_a_nonservice_writer_steals_reserved_revision(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1)
    prepared = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("desired-stolen-head-query"),
            current_work_ref="work-one",
        )
    )
    request = ManagedDesiredSetRequest(
        query_ref=prepared.query_ref,
        logical_choice_id=_digest("desired-stolen-head-choice"),
        capability_ids=(),
    )
    original = EngineComposition.process

    def crash_on_desired(composition: EngineComposition, event: EngineEvent) -> Transition:
        if event.kind == "ReassessmentRequested":
            raise RuntimeError("simulated reservation crash before stolen head")
        return original(composition, event)

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(EngineComposition, "process", crash_on_desired)
        with pytest.raises(RuntimeError, match="before stolen head"):
            setup.service.set_desired(request)
    pending = setup.store.load_pending_desired_set(_scope())
    with open_managed_engine_composition(
        registry=setup.registry,
        artifact=setup.artifact,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        policy_store_root=setup.policy_root,
        skill_cas_runtime=setup.skill_runtime,
    ) as composition:
        composition.process(
            replace(
                pending.event,
                event_id="event-nonservice-stolen-desired-revision",
            )
        )

    with pytest.raises(ManagedDesiredSetConflictError, match="another event"):
        setup.service.set_desired(request)

    still_pending = setup.store.load_pending_desired_set(_scope())
    assert still_pending.desired_set_ref == pending.desired_set_ref
    assert not still_pending.committed


@pytest.mark.parametrize("requested_limit", [0, 1, 5])
def test_service_prepares_one_bounded_ready_or_abstained_result(
    tmp_path: Path,
    requested_limit: int,
) -> None:
    setup = _setup(tmp_path, requested_limit=requested_limit)
    request = ManagedQueryRequest(
        logical_query_id=_digest("logical-query"),
        current_work_ref="work-one",
    )

    result = setup.service.prepare(request)
    record = setup.store.load(result.query_ref)

    assert type(result) is ManagedQueryServiceResult
    assert record.planned
    assert result.prepared.plan_id == record.plan_id == "plan-initial"
    assert len(result.prepared.selections) == requested_limit
    assert len(result.prepared.selections) <= 5
    assert result.prepared.status == ("abstained" if requested_limit == 0 else "ready")
    assert all(
        set(summary.__slots__) == {"action_id", "entity_id", "kind"} for summary in result.actions
    )
    if requested_limit:
        assert [summary.kind for summary in result.actions] == ["PresentBundle"]
    else:
        assert result.actions == ()
    for operation in (copy.copy, copy.deepcopy, pickle.dumps):
        with pytest.raises(TypeError):
            operation(result)


def test_service_returns_no_challenge_without_current_pending_consent(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=0)

    result = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("no-consent-query"),
            current_work_ref="work-one",
        )
    )

    assert result.challenge is None
    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)


def test_service_publishes_one_safe_current_consent_challenge_without_reranking(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    initial, _request = _commit_pending_consent(setup)
    calls_before = tuple(setup.facts.calls)

    result = setup.service.reopen(initial.query_ref)

    challenge = result.challenge
    assert type(challenge) is ManagedConsentChallengeProjection
    assert set(challenge.__slots__) == {
        "audience",
        "capability_id",
        "challenge_digest",
        "expires_at",
        "kind",
    }
    assert challenge.capability_id == "skill:installable"
    assert challenge.kind == "skill"
    assert challenge.audience == CONSENT_AUDIENCE
    assert challenge.expires_at == "2026-08-03T13:00:00Z"
    assert tuple(setup.facts.calls) == calls_before
    assert setup.body_source.load_calls == 0
    assert str(tmp_path) not in repr(challenge)
    assert not hasattr(challenge, "execution_binding")
    assert not hasattr(challenge, "challenge_id")
    assert not hasattr(challenge, "selection")
    assert not hasattr(challenge, "proof")
    assert not hasattr(challenge, "scope")
    for operation in (copy.copy, copy.deepcopy, pickle.dumps):
        with pytest.raises(TypeError):
            operation(challenge)


def test_service_resolves_signed_grant_and_recovers_installed_inactive(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup)
    assert desired.challenge is not None

    result = setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))
    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert type(result) is ManagedConsentResolutionResult
    assert result.outcome == recovered.outcome == "installed-inactive"
    assert result.reason_code == recovered.reason_code == "physical-install-applied"
    assert result.next_challenge is recovered.next_challenge is None
    assert result.capability_id == desired.challenge.capability_id
    assert result.kind == desired.challenge.kind
    assert result.challenge_digest == desired.challenge.challenge_digest
    assert result.journal_revision >= desired.journal_revision + 2
    assert len(result.journal_record_digest) == 64
    assert setup.body_source.load_calls == 1
    assert set(result.__slots__) == {
        "actions",
        "capability_id",
        "challenge_digest",
        "journal_record_digest",
        "journal_revision",
        "kind",
        "next_challenge",
        "outcome",
        "reason_code",
    }
    assert str(tmp_path) not in repr(result)
    for forbidden in (
        "scope",
        "challenge_id",
        "driver",
        "binding",
        "verifier",
        "proof",
        "principal_digest",
    ):
        assert not hasattr(result, forbidden)
    for operation in (copy.copy, copy.deepcopy, pickle.dumps):
        with pytest.raises(TypeError):
            operation(result)


def test_service_signed_denial_never_invokes_install_driver(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="signed-denial")
    assert desired.challenge is not None

    result = setup.service.resolve_consent(
        _consent_assertion_payload(
            desired.challenge,
            decision="denied",
            nonce="managed-consent-denial",
        )
    )
    skill_root = setup.skill_runtime.skill_store_root
    displaced = skill_root.with_name("skills-denial-recovery-displaced")
    skill_root.rename(displaced)
    skill_root.mkdir(mode=0o700)
    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert result.outcome == recovered.outcome == "denied"
    assert result.reason_code == "human-denied-install"
    assert setup.body_source.load_calls == 0
    skill_root.rmdir()
    displaced.rename(skill_root)


def test_signed_grant_expired_before_claim_is_retired_once_and_can_be_chosen_again(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    current = [datetime(2026, 8, 3, 12, 0, tzinfo=UTC)]
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        trusted_clock=lambda: current[0],
    )
    desired = _prepare_public_consent(setup, label="signed-expired-before-claim")
    assert desired.challenge is not None

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            EngineComposition,
            "execute_install",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated crash before install claim")
            ),
        )
        with pytest.raises(RuntimeError, match="before install claim"):
            setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    current[0] = datetime(2026, 8, 3, 14, 0, tzinfo=UTC)
    expired = setup.service.recover_consent(desired.challenge.challenge_digest)
    repeated = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert expired.outcome == repeated.outcome == "expired"
    assert expired.reason_code == "install-approval-expired-before-claim"
    assert expired.journal_revision == repeated.journal_revision == desired.journal_revision + 2
    assert expired.journal_record_digest == repeated.journal_record_digest
    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (0,)
    expiry_events = tuple(
        record
        for record in SQLiteEngineStore(setup.journal_path).records(StreamId.from_scope(_scope()))
        if ReplayInput.from_json(record.replay_json).reducer_event.kind == "ActionExpired"
    )
    assert len(expiry_events) == 1

    next_choice = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=desired.query_ref,
            logical_choice_id=_digest("signed-expired-before-claim-next-choice"),
            capability_ids=(desired.challenge.capability_id,),
            expected_previous_desired_set_ref=desired.desired_set_ref,
        )
    )
    assert next_choice.status == "consent-required"
    assert next_choice.challenge is not None
    assert next_choice.challenge.challenge_digest != desired.challenge.challenge_digest


def test_signed_grant_claimed_before_ttl_reconciles_after_ttl_without_reapply_or_expiry(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    current = [datetime(2026, 8, 3, 12, 0, tzinfo=UTC)]
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        trusted_clock=lambda: current[0],
    )
    desired = _prepare_public_consent(setup, label="signed-claimed-before-expiry")
    assert desired.challenge is not None
    original = CtxEngine.authorize_install

    def crash_after_claim(engine: CtxEngine, *args: object, **kwargs: object) -> None:
        original(engine, *args, **kwargs)  # type: ignore[arg-type]
        raise RuntimeError("simulated crash after signed install claim")

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(CtxEngine, "authorize_install", crash_after_claim)
        with pytest.raises(RuntimeError, match="after signed install claim"):
            setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    current[0] = datetime(2026, 8, 3, 14, 0, tzinfo=UTC)
    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "install-failed"
    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (1,)
    assert all(
        ReplayInput.from_json(record.replay_json).reducer_event.kind != "ActionExpired"
        for record in SQLiteEngineStore(setup.journal_path).records(StreamId.from_scope(_scope()))
    )


def test_service_recovery_never_mints_decision_after_precommit_crash(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="precommit-crash")
    assert desired.challenge is not None

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            EngineComposition,
            "process",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated precommit crash")
            ),
        )
        with pytest.raises(RuntimeError, match="precommit crash"):
            setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "reauthentication-required"
    assert recovered.next_challenge == desired.challenge
    assert setup.body_source.load_calls == 0
    resolved = setup.service.resolve_consent(
        _consent_assertion_payload(
            desired.challenge,
            nonce="managed-consent-fresh-after-crash",
        )
    )
    assert resolved.outcome == "installed-inactive"
    assert setup.body_source.load_calls == 1


def test_service_recovers_commit_before_broker_settle_without_reauthentication(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="postcommit-crash")
    assert desired.challenge is not None

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            SQLiteInstallConsentBrokerStore,
            "_settle",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated crash before broker settle")
            ),
        )
        with pytest.raises(RuntimeError, match="guard settlement failed"):
            setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "installed-inactive"
    assert setup.body_source.load_calls == 1


def test_decision_ready_grant_recovery_after_challenge_ttl_needs_no_live_target(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    current = [datetime(2026, 8, 3, 12, 0, tzinfo=UTC)]
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        trusted_clock=lambda: current[0],
    )
    desired = _prepare_public_consent(setup, label="decision-ready-expired-grant")
    assert desired.challenge is not None
    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            SQLiteInstallConsentBrokerStore,
            "_settle",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated decision-ready crash")
            ),
        )
        with pytest.raises(RuntimeError, match="guard settlement failed"):
            setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    current[0] = datetime(2026, 8, 3, 14, 0, tzinfo=UTC)
    skill_root = setup.skill_runtime.skill_store_root
    displaced = skill_root.with_name("skills-decision-ready-expired-displaced")
    skill_root.rename(displaced)
    skill_root.mkdir(mode=0o700)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )

    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "expired"
    assert recovered.reason_code == "install-approval-expired-before-claim"
    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (0,)
    skill_root.rmdir()
    displaced.rename(skill_root)


def test_service_rejects_unknown_human_identity_before_state_or_driver_access(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="wrong-human")
    assert desired.challenge is not None

    def forbidden_lookup(*_args: object, **_kwargs: object) -> object:
        raise AssertionError("broker lookup must follow trusted verifier selection")

    monkeypatch.setattr(
        InstallConsentBrokerService,
        "status_by_challenge_digest",
        forbidden_lookup,
    )
    with pytest.raises(UnknownHumanDecisionVerifier):
        setup.service.resolve_consent(
            _consent_assertion_payload(
                desired.challenge,
                principal_digest=_digest("unregistered-principal"),
            )
        )

    assert setup.body_source.load_calls == 0


def test_service_target_drift_does_not_burn_signed_assertion(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="target-drift")
    assert desired.challenge is not None
    payload = _consent_assertion_payload(desired.challenge)
    skill_root = setup.skill_runtime.skill_store_root
    displaced = skill_root.with_name("skills-displaced")
    skill_root.rename(displaced)
    skill_root.mkdir(mode=0o700)

    with pytest.raises(RuntimeError, match="root changed"):
        setup.service.resolve_consent(payload)

    skill_root.rmdir()
    displaced.rename(skill_root)
    result = setup.service.resolve_consent(payload)

    assert result.outcome == "installed-inactive"
    assert setup.body_source.load_calls == 1


def test_target_replacement_after_authentication_never_reaches_broker_guard_or_driver(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="post-auth-target-drift")
    assert desired.challenge is not None
    skill_root = setup.skill_runtime.skill_store_root
    displaced = skill_root.with_name("skills-post-auth-displaced")
    original = InstallConsentBrokerService.authenticate
    replaced = False

    def authenticate_then_replace_target(
        broker: InstallConsentBrokerService,
        *args: object,
        **kwargs: object,
    ) -> object:
        nonlocal replaced
        authorization = original(broker, *args, **kwargs)  # type: ignore[arg-type]
        if not replaced:
            replaced = True
            skill_root.rename(displaced)
            skill_root.mkdir(mode=0o700)
        return authorization

    monkeypatch.setattr(
        InstallConsentBrokerService,
        "authenticate",
        authenticate_then_replace_target,
    )
    with pytest.raises(RuntimeError, match="root changed"):
        setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)
        assert connection.execute(
            "SELECT count(*) FROM engine_journal WHERE event_id LIKE 'ctx-interactive-install:%'"
        ).fetchone() == (0,)

    skill_root.rmdir()
    displaced.rename(skill_root)
    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "reauthentication-required"
    assert recovered.next_challenge == desired.challenge


def test_target_replacement_after_decision_commit_never_reaches_claim_or_driver(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="post-commit-target-drift")
    assert desired.challenge is not None
    skill_root = setup.skill_runtime.skill_store_root
    displaced = skill_root.with_name("skills-post-commit-displaced")
    original = ManagedQueryService._finish_settled_consent  # noqa: SLF001
    replaced = False

    def replace_target_before_execution(
        service: ManagedQueryService,
        *args: object,
        **kwargs: object,
    ) -> ManagedConsentResolutionResult:
        nonlocal replaced
        if not replaced:
            replaced = True
            skill_root.rename(displaced)
            skill_root.mkdir(mode=0o700)
        return original(service, *args, **kwargs)  # type: ignore[arg-type]

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            ManagedQueryService,
            "_finish_settled_consent",
            replace_target_before_execution,
        )
        with pytest.raises(RuntimeError, match="root changed"):
            setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    assert setup.body_source.load_calls == 0
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (0,)

    skill_root.rmdir()
    displaced.rename(skill_root)
    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "installed-inactive"
    assert setup.body_source.load_calls == 1


def test_service_policy_drift_does_not_burn_signed_assertion(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="signed-policy-drift")
    assert desired.challenge is not None
    payload = _consent_assertion_payload(desired.challenge)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )

    with pytest.raises(ManagedQueryHeadDriftError, match="policy changed"):
        setup.service.resolve_consent(payload)

    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)
    result = setup.service.resolve_consent(payload)

    assert result.outcome == "installed-inactive"
    assert setup.body_source.load_calls == 1


def test_concurrent_signed_resolution_executes_install_at_most_once(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="signed-concurrency")
    assert desired.challenge is not None
    payload = _consent_assertion_payload(desired.challenge)
    peer = _open_peer_service(setup)

    def resolve(service: ManagedQueryService) -> str:
        try:
            return service.resolve_consent(payload).outcome
        except ManagedQueryServiceError:
            return "already-consumed"

    with ThreadPoolExecutor(max_workers=2) as pool:
        outcomes = tuple(pool.map(resolve, (setup.service, peer)))

    assert sorted(outcomes) == ["already-consumed", "installed-inactive"]
    assert setup.body_source.load_calls == 1
    assert (
        setup.service.recover_consent(desired.challenge.challenge_digest).outcome
        == "installed-inactive"
    )


def test_pending_consent_recovery_requires_no_verifier_or_authentication(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="pending-recovery")
    assert desired.challenge is not None
    monkeypatch.setattr(
        InstallConsentBrokerService,
        "authenticate",
        lambda *_args, **_kwargs: (_ for _ in ()).throw(
            AssertionError("recovery must not authenticate")
        ),
    )

    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "consent-required"
    assert recovered.reason_code == "fresh-human-decision-required"
    assert recovered.next_challenge == desired.challenge
    assert setup.body_source.load_calls == 0


def test_terminal_broker_expiry_durably_retires_pending_consent_and_allows_next_choice(
    tmp_path: Path,
) -> None:
    current = [datetime(2026, 8, 3, 12, 0, tzinfo=UTC)]
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        trusted_clock=lambda: current[0],
    )
    desired = _prepare_public_consent(setup, label="terminal-expiry")
    assert desired.challenge is not None
    current[0] = datetime(2026, 8, 3, 14, 0, tzinfo=UTC)
    skill_root = setup.skill_runtime.skill_store_root
    displaced = skill_root.with_name("skills-expiry-displaced")
    skill_root.rename(displaced)
    skill_root.mkdir(mode=0o700)
    persist_install_policy(
        InstallConsentPolicy(skill_mode="preapproved-auto"),
        setup.policy_root,
    )

    expired = setup.service.recover_consent(desired.challenge.challenge_digest)
    repeated = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert expired.outcome == repeated.outcome == "expired"
    assert expired.journal_revision == repeated.journal_revision == desired.journal_revision + 1
    assert expired.journal_record_digest == repeated.journal_record_digest
    with setup.service._open_consent_composition(  # noqa: SLF001
        setup.artifact,
        include_actuators=False,
    ) as composition:
        state = composition.snapshot(_scope()).state
        assert state is not None
        assert state.pending_consents == ()
    with sqlite3.connect(setup.journal_path) as connection:
        assert connection.execute("SELECT count(*) FROM engine_install_claims").fetchone() == (0,)
        assert connection.execute("SELECT count(*) FROM engine_install_outcomes").fetchone() == (0,)

    skill_root.rmdir()
    displaced.rename(skill_root)
    persist_install_policy(InstallConsentPolicy.safe_default(), setup.policy_root)

    next_choice = setup.service.set_desired(
        ManagedDesiredSetRequest(
            query_ref=desired.query_ref,
            logical_choice_id=_digest("terminal-expiry-next-choice"),
            capability_ids=(desired.challenge.capability_id,),
            expected_previous_desired_set_ref=desired.desired_set_ref,
        )
    )
    assert next_choice.status == "consent-required"
    assert next_choice.challenge is not None
    assert next_choice.challenge.challenge_digest != desired.challenge.challenge_digest


def test_consent_expiry_recovers_after_journal_commit_before_result(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    current = [datetime(2026, 8, 3, 12, 0, tzinfo=UTC)]
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        trusted_clock=lambda: current[0],
    )
    desired = _prepare_public_consent(setup, label="expiry-result-crash")
    assert desired.challenge is not None
    current[0] = datetime(2026, 8, 3, 14, 0, tzinfo=UTC)
    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            ManagedConsentResolutionResult,
            "_create",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated crash after expiry journal commit")
            ),
        )
        with pytest.raises(RuntimeError, match="after expiry journal commit"):
            setup.service.recover_consent(desired.challenge.challenge_digest)

    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "expired"
    assert recovered.journal_revision == desired.journal_revision + 1
    expiry_events = tuple(
        record
        for record in SQLiteEngineStore(setup.journal_path).records(StreamId.from_scope(_scope()))
        if ReplayInput.from_json(record.replay_json).reducer_event.kind == "InstallConsentExpired"
    )
    assert len(expiry_events) == 1


def test_expired_old_challenge_cannot_cancel_refreshed_current_consent(
    tmp_path: Path,
) -> None:
    current = [datetime(2026, 8, 3, 12, 0, tzinfo=UTC)]
    setup = _setup(
        tmp_path,
        requested_limit=1,
        installable=True,
        trusted_clock=lambda: current[0],
    )
    desired = _prepare_public_consent(setup, label="old-expired-refreshed")
    assert desired.challenge is not None
    old_challenge_id = setup.consent_broker.status_by_challenge_digest(
        desired.challenge.challenge_digest
    ).challenge.challenge_id
    original = setup.managed_input.decision_event
    with setup.service._open_consent_composition(setup.artifact) as composition:  # noqa: SLF001
        composition.process(
            replace(
                original,
                event_id="event-refresh-before-old-consent-expiry",
                kind="ProviderSubmissionObserved",
                expected_revision=desired.journal_revision,
                payload={"capabilities": []},
            )
        )
        before = composition.snapshot(_scope())
        assert before.state is not None
        replacement = before.state.pending_consents
        assert len(replacement) == 1
        assert replacement[0].consent_id != old_challenge_id
    current[0] = datetime(2026, 8, 3, 14, 0, tzinfo=UTC)

    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "superseded"
    with setup.service._open_consent_composition(setup.artifact) as composition:  # noqa: SLF001
        after = composition.snapshot(_scope())
        assert after.revision == before.revision
        assert after.record_digest == before.record_digest
        assert after.state is not None
        assert after.state.pending_consents == replacement


def test_wrong_assertion_audience_is_rejected_before_broker_lookup(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="wrong-audience")
    assert desired.challenge is not None
    monkeypatch.setattr(
        InstallConsentBrokerService,
        "status_by_challenge_digest",
        lambda *_args, **_kwargs: (_ for _ in ()).throw(
            AssertionError("wrong audience must not reach broker lookup")
        ),
    )

    with pytest.raises(ManagedQueryServiceError, match="audience"):
        setup.service.resolve_consent(
            _consent_assertion_payload(
                desired.challenge,
                audience="wrong-managed-audience",
            )
        )

    assert setup.body_source.load_calls == 0


@pytest.mark.parametrize("failure", ["signature", "expired"])
def test_invalid_signed_assertion_does_not_mutate_consent_or_journal(
    tmp_path: Path,
    failure: str,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label=f"invalid-{failure}")
    assert desired.challenge is not None
    journal_before = tuple(
        SQLiteEngineStore(setup.journal_path).records(StreamId.from_scope(_scope()))
    )
    payload = _consent_assertion_payload(
        desired.challenge,
        nonce=f"invalid-{failure}-nonce",
        valid_proof=failure != "signature",
        issued_at=("2026-08-03T11:00:00Z" if failure == "expired" else NOW),
        expires_at=("2026-08-03T11:30:00Z" if failure == "expired" else "2026-08-03T12:30:00Z"),
    )
    expected_error = (
        ConsentBrokerDecisionRejected if failure == "signature" else ConsentBrokerExpired
    )

    with pytest.raises(expected_error):
        setup.service.resolve_consent(payload)

    broker_record = setup.consent_broker.status_by_challenge_digest(
        desired.challenge.challenge_digest
    )
    assert broker_record.state == "pending"
    assert (
        tuple(SQLiteEngineStore(setup.journal_path).records(StreamId.from_scope(_scope())))
        == journal_before
    )
    assert setup.body_source.load_calls == 0


def test_head_drift_is_rejected_before_broker_authentication(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="signed-head-drift")
    assert desired.challenge is not None
    head = tuple(SQLiteEngineStore(setup.journal_path).records(StreamId.from_scope(_scope())))[-1]
    request = next(
        action
        for action in Transition.from_json(head.transition_json).actions
        if action.kind == "RequestConsent"
    )
    _commit_consent_decision(setup, request)
    monkeypatch.setattr(
        InstallConsentBrokerService,
        "authenticate",
        lambda *_args, **_kwargs: (_ for _ in ()).throw(
            AssertionError("stale head must be rejected before authentication")
        ),
    )

    with pytest.raises(ManagedQueryHeadDriftError, match="current pending"):
        setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    assert (
        setup.consent_broker.status_by_challenge_digest(desired.challenge.challenge_digest).state
        == "pending"
    )


def test_signed_install_indeterminate_then_recovers_failed(tmp_path: Path) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    setup.body_source.fail_loads_remaining = 1
    desired = _prepare_public_consent(setup, label="signed-indeterminate")
    assert desired.challenge is not None

    indeterminate = setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))
    failed = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert indeterminate.outcome == "install-indeterminate"
    assert indeterminate.reason_code == "physical-install-outcome-indeterminate"
    assert failed.outcome == "install-failed"
    assert failed.reason_code == "physical-install-failed"
    assert setup.body_source.load_calls == 1


def test_recovery_quarantines_decision_when_journal_head_advanced(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="signed-quarantine")
    assert desired.challenge is not None
    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(
            EngineComposition,
            "process",
            lambda *_args, **_kwargs: (_ for _ in ()).throw(
                RuntimeError("simulated precommit crash")
            ),
        )
        with pytest.raises(RuntimeError, match="precommit crash"):
            setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))
    original = setup.managed_input.decision_event
    with setup.service._open_consent_composition(setup.artifact) as composition:  # noqa: SLF001
        composition.process(
            replace(
                original,
                event_id="event-signed-consent-head-advanced",
                kind="ProviderSubmissionObserved",
                expected_revision=desired.journal_revision,
                payload={"capabilities": []},
            )
        )

    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "quarantined"
    assert recovered.reason_code == "journal-head-advanced"
    assert recovered.next_challenge is None
    assert setup.body_source.load_calls == 0


def test_signed_recovery_after_receipt_crash_does_not_reinvoke_driver(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    desired = _prepare_public_consent(setup, label="signed-receipt-crash")
    assert desired.challenge is not None
    original = EngineComposition.execute_install

    def crash_after_receipt(
        composition: EngineComposition,
        *args: object,
        **kwargs: object,
    ) -> object:
        original(composition, *args, **kwargs)  # type: ignore[arg-type]
        raise RuntimeError("simulated signed crash after receipt")

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(EngineComposition, "execute_install", crash_after_receipt)
        with pytest.raises(RuntimeError, match="after receipt"):
            setup.service.resolve_consent(_consent_assertion_payload(desired.challenge))

    recovered = setup.service.recover_consent(desired.challenge.challenge_digest)

    assert recovered.outcome == "installed-inactive"
    assert setup.body_source.load_calls == 1


def test_service_challenge_retry_reopen_and_host_aliases_are_idempotent(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    setup.inputs.values["codex-turn"] = setup.managed_input
    setup.inputs.values["claude-hook"] = setup.managed_input
    initial, _request = _commit_pending_consent(setup, logical_query_id="host-consent-query")
    calls_before = tuple(setup.facts.calls)

    codex = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("host-consent-query"),
            current_work_ref="codex-turn",
        )
    )
    claude = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("host-consent-query"),
            current_work_ref="claude-hook",
        )
    )
    reopened = setup.service.reopen(initial.query_ref)

    assert codex.challenge == claude.challenge == reopened.challenge
    assert codex.challenge is not None
    assert tuple(setup.facts.calls) == calls_before
    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (1,)


def test_service_concurrent_challenge_publication_converges_without_replanning(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, _request = _commit_pending_consent(setup)
    calls_before = tuple(setup.facts.calls)

    with ThreadPoolExecutor(max_workers=4) as pool:
        results = tuple(pool.map(setup.service.reopen, (initial.query_ref,) * 8))

    assert len({result.challenge.challenge_digest for result in results if result.challenge}) == 1
    assert tuple(setup.facts.calls) == calls_before
    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (1,)


def test_service_reopen_recovers_after_challenge_publish_before_result(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, _request = _commit_pending_consent(setup)

    def crash_after_publication(*_args: object, **_kwargs: object) -> object:
        raise RuntimeError("simulated crash after challenge publication")

    with monkeypatch.context() as scoped_patch:
        scoped_patch.setattr(ManagedQueryServiceResult, "_create", crash_after_publication)
        with pytest.raises(RuntimeError, match="simulated crash"):
            setup.service.reopen(initial.query_ref)
    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (1,)

    calls_before = tuple(setup.facts.calls)
    recovered = setup.service.reopen(initial.query_ref)

    assert recovered.challenge is not None
    assert tuple(setup.facts.calls) == calls_before


def test_service_rejects_decision_committed_during_registry_binding(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, request = _commit_pending_consent(setup)
    original = EngineComposition.resolve_install_execution_binding

    def resolve_then_decide(
        composition: EngineComposition,
        action: HostAction,
        selection: CapabilityPlanSelectionV3,
    ) -> InstallExecutionBinding:
        binding = original(composition, action, selection)
        _commit_consent_decision(setup, request)
        return binding

    monkeypatch.setattr(
        EngineComposition,
        "resolve_install_execution_binding",
        resolve_then_decide,
    )
    with pytest.raises(ManagedQueryHeadDriftError, match="changed"):
        setup.service.reopen(initial.query_ref)

    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)


def test_service_never_mixes_plan_a_result_with_plan_b_consent(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, _request = _commit_pending_consent(setup)
    original_resolve = EngineComposition.resolve_install_execution_binding
    original_snapshot = EngineComposition.snapshot
    drifted = False

    def resolve_then_replan(
        composition: EngineComposition,
        action: HostAction,
        selection: CapabilityPlanSelectionV3,
    ) -> InstallExecutionBinding:
        nonlocal drifted
        binding = original_resolve(composition, action, selection)
        drifted = True
        return binding

    def snapshot_with_plan_drift(composition: EngineComposition, scope: ScopeRef) -> object:
        current = original_snapshot(composition, scope)
        if not drifted:
            return current
        assert current.state is not None
        committed = current.state.committed_plan
        assert isinstance(committed, CommittedPlanV3)
        return SimpleNamespace(
            revision=current.revision,
            record_digest=_digest("plan-race-b-head"),
            state=SimpleNamespace(
                committed_plan=replace(committed, plan_id="plan-race-b"),
                pending_consents=current.state.pending_consents,
            ),
        )

    monkeypatch.setattr(
        EngineComposition,
        "resolve_install_execution_binding",
        resolve_then_replan,
    )
    monkeypatch.setattr(EngineComposition, "snapshot", snapshot_with_plan_drift)
    with pytest.raises(ManagedQueryHeadDriftError, match="changed"):
        setup.service.reopen(initial.query_ref)

    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)


def test_service_rejects_decision_committed_during_broker_publication(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, request = _commit_pending_consent(setup)
    original = InstallConsentBrokerService.prepare

    def publish_then_decide(broker: InstallConsentBrokerService, **kwargs: object) -> object:
        challenge = original(broker, **kwargs)  # type: ignore[arg-type]
        _commit_consent_decision(setup, request)
        return challenge

    monkeypatch.setattr(InstallConsentBrokerService, "prepare", publish_then_decide)
    with pytest.raises(ManagedQueryHeadDriftError, match="stale"):
        setup.service.reopen(initial.query_ref)

    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (1,)


def test_service_rejects_decision_committed_during_broker_status(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, request = _commit_pending_consent(setup)
    original = InstallConsentBrokerService.status
    decided = False

    def decide_then_status(broker: InstallConsentBrokerService, challenge_id: str) -> object:
        nonlocal decided
        if not decided:
            decided = True
            _commit_consent_decision(setup, request)
        return original(broker, challenge_id)

    monkeypatch.setattr(InstallConsentBrokerService, "status", decide_then_status)
    with pytest.raises(ManagedQueryHeadDriftError, match="stale"):
        setup.service.reopen(initial.query_ref)

    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (1,)


def test_service_projects_only_a_pending_broker_record(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, _request = _commit_pending_consent(setup)
    original = InstallConsentBrokerService.status

    def non_pending_status(broker: InstallConsentBrokerService, challenge_id: str) -> object:
        return replace(original(broker, challenge_id), state="decision-ready")

    monkeypatch.setattr(InstallConsentBrokerService, "status", non_pending_status)
    calls_before = tuple(setup.facts.calls)
    result = setup.service.reopen(initial.query_ref)

    assert result.challenge is None
    assert tuple(setup.facts.calls) == calls_before
    assert setup.body_source.load_calls == 0


def test_service_fails_closed_when_pending_consent_has_no_publication_authority(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, _request = _commit_pending_consent(setup)
    without_broker = open_managed_query_service(
        registry=setup.registry,
        query_store=setup.store,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        input_authority=setup.inputs,
        policy_store_root=setup.policy_root,
    )

    with pytest.raises(ManagedQueryServiceError, match="publication authorities"):
        without_broker.reopen(initial.query_ref)

    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)


def test_service_rejects_pending_consent_without_a_physical_actuator(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, _request = _commit_pending_consent(setup)

    no_actuator = open_managed_query_service(
        registry=setup.registry,
        query_store=setup.store,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        input_authority=setup.inputs,
        consent_broker=setup.consent_broker,
        policy_store_root=setup.policy_root,
    )

    with pytest.raises(RuntimeError, match="no physical installation actuator"):
        no_actuator.reopen(initial.query_ref)

    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)


def test_service_rejects_actuator_target_drift_before_broker_publication(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial, _request = _commit_pending_consent(setup)
    skill_root = setup.skill_runtime.skill_store_root
    skill_root.rename(skill_root.with_name("skills-old"))
    skill_root.mkdir(mode=0o700)

    with pytest.raises(RuntimeError, match="root changed"):
        setup.service.reopen(initial.query_ref)

    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)


def test_service_exact_prepare_retry_and_reopen_plan_only_once(tmp_path: Path) -> None:
    setup = _setup(tmp_path)
    request = ManagedQueryRequest(
        logical_query_id=_digest("retry-query"),
        current_work_ref="work-one",
    )

    first = setup.service.prepare(request)
    planned_calls = tuple(setup.facts.calls)
    retried = setup.service.prepare(request)
    reopened = setup.service.reopen(first.query_ref)

    assert setup.facts.calls == list(planned_calls)
    assert first.query_ref == retried.query_ref == reopened.query_ref
    assert first.prepared.decision_digest == retried.prepared.decision_digest
    assert first.prepared.decision_digest == reopened.prepared.decision_digest
    assert first.actions == retried.actions == reopened.actions


@pytest.mark.parametrize("crash_point", ["registered", "revision-one", "committed"])
def test_service_reopen_converges_after_each_pre_mark_crash(
    tmp_path: Path,
    crash_point: str,
) -> None:
    setup = _setup(tmp_path)
    logical_query_id = _digest(f"crash:{crash_point}")
    record = _register(setup, logical_query_id)
    value = setup.managed_input
    if crash_point != "registered":
        with open_managed_engine_composition(
            registry=setup.registry,
            artifact=value.artifact,
            journal_path=setup.journal_path,
            benefit_audit_path=setup.audit_path,
            benefit_facts_port=setup.facts,
            net_benefit_policy=setup.policy,
            material_port=setup.materials,  # type: ignore[arg-type]
            install_bundle_port=setup.installs,
        ) as composition:
            if crash_point == "revision-one":
                composition.process(value.session_started)
            else:
                composition.advance_managed_query(
                    session_started=value.session_started,
                    planning_observed=value.decision_event,
                )
    calls_before_reopen = tuple(setup.facts.calls)

    result = setup.service.reopen(record.query_ref)
    planned = setup.store.load(record.query_ref)

    assert planned.planned
    assert result.prepared.plan_id == planned.plan_id
    if crash_point == "committed":
        assert setup.facts.calls == list(calls_before_reopen)
    else:
        assert len(setup.facts.calls) > len(calls_before_reopen)


def test_service_concurrent_same_request_converges_to_one_plan(tmp_path: Path) -> None:
    setup = _setup(tmp_path)
    request = ManagedQueryRequest(
        logical_query_id=_digest("concurrent-query"),
        current_work_ref="work-one",
    )

    with ThreadPoolExecutor(max_workers=4) as pool:
        results = tuple(pool.map(setup.service.prepare, (request,) * 8))

    assert {result.query_ref for result in results} == {results[0].query_ref}
    assert {result.prepared.decision_digest for result in results} == {
        results[0].prepared.decision_digest
    }
    planning_calls = tuple(setup.facts.calls)
    setup.service.reopen(results[0].query_ref)
    assert tuple(setup.facts.calls) == planning_calls
    assert set(planning_calls) == {
        "agent:reviewer",
        "harness:python-runner",
        "mcp-server:docs",
        "skill:lint",
        "skill:test",
        "skill:types",
    }


def test_service_concurrent_distinct_logical_ids_reject_one_before_new_planning(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path)
    requests = (
        ManagedQueryRequest(
            logical_query_id=_digest("concurrent-left"),
            current_work_ref="work-one",
        ),
        ManagedQueryRequest(
            logical_query_id=_digest("concurrent-right"),
            current_work_ref="work-one",
        ),
    )

    def attempt(request: ManagedQueryRequest) -> ManagedQueryServiceResult | Exception:
        try:
            return setup.service.prepare(request)
        except Exception as exc:  # the exact typed loser is asserted below
            return exc

    with ThreadPoolExecutor(max_workers=2) as pool:
        outcomes = tuple(pool.map(attempt, requests))

    assert sum(type(outcome) is ManagedQueryServiceResult for outcome in outcomes) == 1
    assert sum(type(outcome) is ManagedQueryStoreConflict for outcome in outcomes) == 1
    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_queries").fetchone() == (1,)


def test_service_rejects_distinct_event_reusing_scope_and_plan_before_mutation(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path)
    setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("scope-plan-owner"),
            current_work_ref="work-one",
        )
    )
    distinct_event = replace(
        setup.managed_input.decision_event,
        event_id="event-distinct-same-plan",
        causation_id="cause-distinct-same-plan",
    )
    setup.inputs.values["same-plan-distinct-event"] = ManagedQueryInput(
        artifact=setup.artifact,
        session_started=setup.managed_input.session_started,
        decision_event=distinct_event,
    )
    calls_before = tuple(setup.facts.calls)
    journal_before = setup.journal_path.read_bytes()

    with pytest.raises(ManagedQueryStoreConflict, match="another logical identity"):
        setup.service.prepare(
            ManagedQueryRequest(
                logical_query_id=_digest("scope-plan-substitute"),
                current_work_ref="same-plan-distinct-event",
            )
        )

    assert tuple(setup.facts.calls) == calls_before
    assert setup.journal_path.read_bytes() == journal_before
    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_queries").fetchone() == (1,)


def test_service_rejects_scope_and_plan_reserved_by_unplanned_registration(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path)
    owner = _register(setup, _digest("unplanned-scope-plan-owner"))
    distinct_started = replace(
        setup.managed_input.session_started,
        event_id="event-unplanned-substitute-started",
        causation_id="cause-unplanned-substitute-started",
    )
    distinct_event = replace(
        setup.managed_input.decision_event,
        event_id="event-unplanned-substitute-decision",
        causation_id=distinct_started.event_id,
    )
    setup.inputs.values["unplanned-same-plan-distinct-event"] = ManagedQueryInput(
        artifact=setup.artifact,
        session_started=distinct_started,
        decision_event=distinct_event,
    )

    with pytest.raises(ManagedQueryStoreConflict, match="scope and plan"):
        setup.service.prepare(
            ManagedQueryRequest(
                logical_query_id=_digest("unplanned-scope-plan-substitute"),
                current_work_ref="unplanned-same-plan-distinct-event",
            )
        )

    assert not owner.planned
    assert setup.facts.calls == []
    assert not setup.journal_path.exists()
    assert not setup.audit_path.exists()
    with sqlite3.connect(setup.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_queries").fetchone() == (1,)


def test_service_is_host_neutral_for_equivalent_codex_and_claude_refs(tmp_path: Path) -> None:
    setup = _setup(tmp_path)
    setup.inputs.values["codex-turn"] = setup.managed_input
    setup.inputs.values["claude-hook"] = setup.managed_input
    logical_id = _digest("host-neutral-query")

    codex = setup.service.prepare(
        ManagedQueryRequest(logical_query_id=logical_id, current_work_ref="codex-turn")
    )
    claude = setup.service.prepare(
        ManagedQueryRequest(logical_query_id=logical_id, current_work_ref="claude-hook")
    )

    assert codex.query_ref == claude.query_ref
    assert codex.prepared.decision_digest == claude.prepared.decision_digest
    assert codex.actions == claude.actions
    assert all(
        setup.facts.calls.count(capability_id) == 2 for capability_id in set(setup.facts.calls)
    )


def test_service_rejects_foreign_registry_handle_before_persistence(tmp_path: Path) -> None:
    owned = _setup(tmp_path / "owned")
    foreign = _setup(tmp_path / "foreign")
    owned.inputs.values["foreign-work"] = foreign.managed_input

    with pytest.raises(ManagedQueryServiceError, match="not issued"):
        owned.service.prepare(
            ManagedQueryRequest(
                logical_query_id=_digest("foreign-query"),
                current_work_ref="foreign-work",
            )
        )

    with sqlite3.connect(owned.store_path) as connection:
        assert connection.execute("SELECT count(*) FROM managed_queries").fetchone() == (0,)


def test_service_fails_closed_when_captured_authority_drifts(tmp_path: Path) -> None:
    setup = _setup(tmp_path)
    setup.facts.benefit_facts_snapshot_digest = _digest("drifted-facts")

    with pytest.raises(ValueError, match="snapshot does not match"):
        setup.service.prepare(
            ManagedQueryRequest(
                logical_query_id=_digest("drift-query"),
                current_work_ref="work-one",
            )
        )

    assert not setup.journal_path.exists()
    assert not setup.audit_path.exists()


def test_service_factory_rejects_output_path_aliases_before_use(tmp_path: Path) -> None:
    setup = _setup(tmp_path)

    with pytest.raises(ValueError, match="must be distinct"):
        open_managed_query_service(
            registry=setup.registry,
            query_store=setup.store,
            journal_path=setup.store_path,
            benefit_audit_path=setup.audit_path,
            benefit_facts_port=setup.facts,
            net_benefit_policy=setup.policy,
            material_port=setup.materials,  # type: ignore[arg-type]
            install_bundle_port=setup.installs,
            input_authority=setup.inputs,
        )


def test_service_factory_with_consent_recovery_authority_does_not_create_journal(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path)

    assert not setup.journal_path.exists()
    assert not setup.audit_path.exists()

    colliding_broker = InstallConsentBrokerService(
        store=SQLiteInstallConsentBrokerStore(
            setup.journal_path,
            audience=CONSENT_AUDIENCE,
        ),
        verifier=None,
        workspace_identity_digest=WORKSPACE_DIGEST,
        release_root_digest=RELEASE_ROOT_DIGEST,
        trusted_utc_now=lambda: datetime(2026, 8, 3, 12, 0, tzinfo=UTC),
    )
    with pytest.raises(ValueError, match="persistence paths must be distinct"):
        open_managed_query_service(
            registry=setup.registry,
            query_store=setup.store,
            journal_path=setup.journal_path,
            benefit_audit_path=setup.audit_path,
            benefit_facts_port=setup.facts,
            net_benefit_policy=setup.policy,
            material_port=setup.materials,  # type: ignore[arg-type]
            install_bundle_port=setup.installs,
            input_authority=setup.inputs,
            consent_broker=colliding_broker,
        )
    with pytest.raises(ValueError, match="absolute Path"):
        open_managed_query_service(
            registry=setup.registry,
            query_store=setup.store,
            journal_path=Path("relative-journal.sqlite3"),
            benefit_audit_path=setup.audit_path,
            benefit_facts_port=setup.facts,
            net_benefit_policy=setup.policy,
            material_port=setup.materials,  # type: ignore[arg-type]
            install_bundle_port=setup.installs,
            input_authority=setup.inputs,
        )


def test_service_rejects_malformed_or_corrupt_references(tmp_path: Path) -> None:
    setup = _setup(tmp_path)
    result = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("corrupt-query"),
            current_work_ref="work-one",
        )
    )
    with pytest.raises(ValueError, match="opaque managed-query reference"):
        setup.service.reopen("../../private/queries.sqlite3")

    with sqlite3.connect(setup.store_path) as connection:
        connection.execute(
            "UPDATE managed_queries SET decision_digest = ? WHERE query_ref = ?",
            (_digest("substituted"), result.query_ref),
        )
        connection.commit()
    with pytest.raises(RuntimeError, match="authentication failed"):
        setup.service.reopen(result.query_ref)


def test_service_public_surface_and_result_do_not_leak_authority_or_content(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path)
    with pytest.raises(ValueError, match="opaque token"):
        ManagedQueryRequest(
            logical_query_id=_digest("privacy-query"),
            current_work_ref=str(tmp_path / "raw prompt and secret"),
        )
    with pytest.raises(TypeError):
        ManagedQueryRequest(  # type: ignore[call-arg]
            logical_query_id=_digest("privacy-query"),
            current_work_ref="work-one",
            raw_prompt="do not persist me",
        )

    result = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("privacy-query"),
            current_work_ref="work-one",
        )
    )

    assert not hasattr(result, "transition")
    assert not hasattr(result, "artifact")
    assert str(tmp_path) not in repr(result)
    assert "work-one" not in repr(result)
    assert all(
        set(action.__slots__) == {"action_id", "entity_id", "kind"} for action in result.actions
    )


def test_service_close_is_idempotent_and_fails_closed(tmp_path: Path) -> None:
    setup = _setup(tmp_path)

    setup.service.close()
    setup.service.close()

    assert setup.service.closed
    with pytest.raises(RuntimeError, match="closed"):
        setup.service.prepare(
            ManagedQueryRequest(
                logical_query_id=_digest("closed-query"),
                current_work_ref="work-one",
            )
        )
    with pytest.raises(RuntimeError, match="closed"):
        setup.service.reopen("mqr_" + "0" * 64)


@pytest.mark.skipif(not hasattr(os, "fork"), reason="POSIX fork contract")
def test_service_is_process_bound(tmp_path: Path) -> None:
    setup = _setup(tmp_path)
    read_fd, write_fd = os.pipe()
    child_pid = os.fork()
    if child_pid == 0:
        os.close(read_fd)
        try:
            setup.service.prepare(
                ManagedQueryRequest(
                    logical_query_id=_digest("forked-query"),
                    current_work_ref="work-one",
                )
            )
        except RuntimeError as exc:
            outcome = b"blocked" if "forked process" in str(exc) else b"wrong-error"
        else:
            outcome = b"allowed"
        os.write(write_fd, outcome)
        os.close(write_fd)
        os._exit(0)
    os.close(write_fd)
    try:
        outcome = os.read(read_fd, 32)
    finally:
        os.close(read_fd)
        os.waitpid(child_pid, 0)

    assert outcome == b"blocked"


def test_service_reports_old_plan_as_superseded_without_reranking(tmp_path: Path) -> None:
    setup = _setup(tmp_path)
    first = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("first-plan"),
            current_work_ref="work-one",
        )
    )
    replacement_surrogate = _surrogate(0)
    replacement_artifact = setup.registry.ingest_graph_store(
        graph_store_path=tmp_path / "graph.sqlite3",
        expected_graph_artifact_digest=setup.artifact.graph_artifact_digest,
        planning_environment_digest=setup.artifact.planning_environment_digest,
        catalog_namespace_digest=setup.artifact.catalog_namespace_digest,
        catalog_retrieval_digest=setup.artifact.catalog_retrieval_digest,
        benefit_facts_snapshot_digest=setup.artifact.benefit_facts_snapshot_digest,
        benefit_policy_snapshot_digest=setup.artifact.benefit_policy_snapshot_digest,
        material_snapshot_digest=setup.artifact.material_snapshot_digest,
        installation_snapshot_digest=setup.artifact.installation_snapshot_digest,
        observation_surrogate=replacement_surrogate,
        planning_schema_version=setup.artifact.planning_schema_version,
    )
    original = setup.managed_input.decision_event
    reference = replacement_artifact.observation_reference
    development = EngineEvent(
        event_id="event-development-observed",
        kind="DevelopmentObserved",
        scope=original.scope,
        expected_revision=2,
        occurred_at=NOW,
        payload={
            "observation_ref": {
                "provider_id": reference.provider_id,
                "opaque_id": reference.opaque_id,
                "content_digest": reference.content_digest,
            }
        },
        correlation_id="plan-replacement",
        causation_id=original.event_id,
        privacy=original.privacy,
        engine_version=original.engine_version,
        planner_version=original.planner_version,
        policy_version=original.policy_version,
        host_descriptor_digest=original.host_descriptor_digest,
        catalog_snapshot_digest=original.catalog_snapshot_digest,
        semantic_model_digest=original.semantic_model_digest,
        semantic_index_digest=original.semantic_index_digest,
        work_signature=_digest("replacement-work"),
        random_seed=1,
    )
    setup.inputs.values["work-replacement"] = ManagedQueryInput(
        artifact=replacement_artifact,
        session_started=setup.managed_input.session_started,
        decision_event=development,
    )
    replacement = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("replacement-plan"),
            current_work_ref="work-replacement",
        )
    )
    calls_after_replacement = tuple(setup.facts.calls)

    with pytest.raises(ManagedQuerySupersededError, match="superseded"):
        setup.service.reopen(first.query_ref)

    assert replacement.prepared.plan_id == "plan-replacement"
    assert replacement.prepared.status == "abstained"
    assert replacement.challenge is None
    assert tuple(setup.facts.calls) == calls_after_replacement
    with sqlite3.connect(setup.consent_store_path) as connection:
        assert connection.execute("SELECT count(*) FROM consent_challenges").fetchone() == (0,)


def test_service_summarizes_task_shift_deactivation_without_exposing_authority(
    tmp_path: Path,
) -> None:
    setup = _setup(tmp_path, requested_limit=1, installable=True)
    initial = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("lifecycle-initial"),
            current_work_ref="work-one",
        )
    )
    original = setup.managed_input.decision_event
    bundle = setup.installs.bundles["skill:installable"]
    with open_managed_engine_composition(
        registry=setup.registry,
        artifact=setup.artifact,
        journal_path=setup.journal_path,
        benefit_audit_path=setup.audit_path,
        benefit_facts_port=setup.facts,
        net_benefit_policy=setup.policy,
        material_port=setup.materials,  # type: ignore[arg-type]
        install_bundle_port=setup.installs,
        interactive_install_decision_guard=lambda _reservation: nullcontext(),
        trusted_utc_now=lambda: datetime(2026, 8, 3, 12, 1, tzinfo=UTC),
    ) as composition:
        snapshot = composition.snapshot(original.scope)
        assert snapshot.state is not None
        committed = snapshot.state.committed_plan
        assert isinstance(committed, CommittedPlanV3)
        capability = committed.capabilities[0]
        desired = composition.process(
            replace(
                original,
                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(
                original,
                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-service-host"),
            target_identity_digest=_digest("managed-service-target"),
        )
        engine = composition._engine  # noqa: SLF001 - exact settlement seam under test.
        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-service-install-observation"),
        )
        install_status = engine.install_execution_status(install)
        assert install_status.observed_at is not None
        install_receipt = replace(
            original,
            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"
        engine.authorize_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=setup.managed_input.session_started.host_descriptor_digest
            or "",
        )
        activation_guard = engine._record_activation_outcome(  # noqa: SLF001
            activation,
            execution_binding=binding,
            execution_authority=engine._issue_activation_outcome_permit(  # noqa: SLF001
                activation,
                binding,
            ),
            observed_material_identity_digest=activation.payload["material_identity"][  # type: ignore[index]
                "identity_digest"
            ],
            verification_digest=_digest("managed-service-activation-observation"),
        )
        activation_status = engine.activation_execution_status(activation)
        assert activation_status.observed_at is not None
        activation_receipt = replace(
            original,
            event_id="event-lifecycle-activation-applied",
            kind="ActionApplied",
            expected_revision=5,
            occurred_at=activation_status.observed_at,
            payload={
                "action_id": activation.action_id,
                "action_kind": activation.kind,
                "action_content_digest": activation.content_digest,
                "action_precondition_revision": activation.precondition_revision,
                "verification": {
                    "schema": MATERIAL_RECEIPT_SCHEMA_V3,
                    "host_state": activation.verification["expected_state"],
                    "capability_id": activation.entity_id,
                    "capability_kind": activation.payload["capability_kind"],
                    "catalog_identity": activation.payload["catalog_identity"],
                    "material_identity": activation.payload["material_identity"],
                    "authorized_material": activation.payload["authorized_material"],
                },
            },
        )
        engine.process_activation_receipt(activation_receipt, activation_guard)

    replacement_surrogate = _surrogate(0)
    replacement_artifact = setup.registry.ingest_graph_store(
        graph_store_path=tmp_path / "graph.sqlite3",
        expected_graph_artifact_digest=setup.artifact.graph_artifact_digest,
        planning_environment_digest=setup.artifact.planning_environment_digest,
        catalog_namespace_digest=setup.artifact.catalog_namespace_digest,
        catalog_retrieval_digest=setup.artifact.catalog_retrieval_digest,
        benefit_facts_snapshot_digest=setup.artifact.benefit_facts_snapshot_digest,
        benefit_policy_snapshot_digest=setup.artifact.benefit_policy_snapshot_digest,
        material_snapshot_digest=setup.artifact.material_snapshot_digest,
        installation_snapshot_digest=setup.artifact.installation_snapshot_digest,
        observation_surrogate=replacement_surrogate,
        planning_schema_version=setup.artifact.planning_schema_version,
    )
    reference = replacement_artifact.observation_reference
    development = replace(
        original,
        event_id="event-lifecycle-development",
        kind="DevelopmentObserved",
        expected_revision=6,
        payload={
            "observation_ref": {
                "provider_id": reference.provider_id,
                "opaque_id": reference.opaque_id,
                "content_digest": reference.content_digest,
            }
        },
        correlation_id="plan-lifecycle-development",
        causation_id="event-lifecycle-activation-applied",
        work_signature=_digest("lifecycle-development-work"),
    )
    setup.inputs.values["work-lifecycle-development"] = ManagedQueryInput(
        artifact=replacement_artifact,
        session_started=setup.managed_input.session_started,
        decision_event=development,
    )
    shifted = setup.service.prepare(
        ManagedQueryRequest(
            logical_query_id=_digest("lifecycle-development"),
            current_work_ref="work-lifecycle-development",
        )
    )
    calls_after_shift = tuple(setup.facts.calls)
    reopened = setup.service.reopen(shifted.query_ref)

    assert initial.prepared.status == "ready"
    assert shifted.prepared.status == "abstained"
    assert [(action.kind, action.entity_id) for action in shifted.actions] == [
        ("DeactivateCapability", "skill:installable")
    ]
    assert shifted.actions == reopened.actions
    assert tuple(setup.facts.calls) == calls_after_shift
    assert not hasattr(shifted.actions[0], "payload")