from __future__ import annotations import hashlib from collections.abc import Mapping import pytest from ctx.engine.content import AuthorizedMaterial, MaterialDescriptor, MaterialIdentity from ctx.engine.installation import InstallPlanDescriptor from ctx.engine.lineage import CatalogCapabilityIdentity from ctx.engine.planning_v3 import InstallPlanningAuthority, LoadPlanningAuthority from ctx.engine.protocol import ( INSTALL_RECEIPT_SCHEMA_V3, MATERIAL_RECEIPT_SCHEMA_V3, PROMPT_CONTEXT_RECEIPT_SCHEMA_V1, EngineEvent, HostAction, ScopeRef, ) from ctx.engine.reducer import InvalidEventError, reduce_replay_v3, reduce_replay_v4 from ctx.engine.replay import ReplayInput, StructuredSurrogate from ctx.engine.state import CapabilityStateV3, CommittedPlanV3, EngineState NOW = "2026-08-02T12:00:00Z" POLICY_DIGEST = hashlib.sha256(b"install-policy").hexdigest() INSTALLABLE_CAPABILITY_IDS = ( "skill:remote", "agent:reviewer", "mcp-server:repository-tools", ) def _digest(value: str) -> str: return hashlib.sha256(value.encode()).hexdigest() def _scope(*, exposure_id: str = "exposure-1") -> ScopeRef: return ScopeRef( tenant_id="tenant-1", workspace_id="workspace-1", repository_id="repository-1", session_id="session-1", exposure_id=exposure_id, host_context_id="host-1", ) def _event( kind: str, revision: int, event_id: str, *, payload: Mapping[str, object] | None = None, correlation_id: str = "plan-v3", scope: ScopeRef | None = None, ) -> EngineEvent: return EngineEvent( event_id=event_id, kind=kind, scope=_scope() if scope is None else scope, expected_revision=revision, occurred_at=NOW, payload={} if payload is None else payload, correlation_id=correlation_id, engine_version="engine-v3", planner_version="planner-v3", policy_version="policy-v3", host_descriptor_digest=_digest("host"), catalog_snapshot_digest=_digest("catalog"), semantic_model_digest=_digest("model"), semantic_index_digest=_digest("index"), work_signature=_digest("work"), random_seed=17, ) def _replay( event: EngineEvent, *, decision: StructuredSurrogate | None = None, ) -> ReplayInput: return ReplayInput( source_event_content_digest=event.content_digest, reducer_event=event, decision_surrogate=decision, reducer_version="ctx-reducer-v3", ) def _replay_v4( event: EngineEvent, *, decision: StructuredSurrogate | None = None, ) -> ReplayInput: return ReplayInput( source_event_content_digest=event.content_digest, reducer_event=event, decision_surrogate=decision, reducer_version="ctx-reducer-v4", ) def _catalog_identity( capability_id: str, *, namespace: str = "catalog-namespace", ) -> CatalogCapabilityIdentity: return CatalogCapabilityIdentity.create( capability_id=capability_id, kind=capability_id.split(":", 1)[0], catalog_namespace_digest=_digest(namespace), ) def _material(capability_id: str, salt: str) -> MaterialIdentity: return MaterialIdentity.create( capability_id=capability_id, kind=capability_id.split(":", 1)[0], content_sha256=_digest(f"content:{salt}"), content_bytes=32, ) def _presentation(capability_id: str, actionability: str) -> dict[str, object]: kind, name = capability_id.split(":", 1) return { "actionability": actionability, "capability_id": capability_id, "catalog_entry_digest": _digest(f"entry:{capability_id}"), "install_descriptor_digest": None, "install_plan_digest": None, "kind": kind, "matching_signals": ["python"], "name": name, "normalized_score_ppm": 900_000, "reason_codes": ["signal-match"], } def _benefit(tier: str = "executable") -> dict[str, object]: return { "tier": tier, "individual_net_benefit_u": 600_000, "marginal_net_benefit_u": 600_000, } def _load_row( capability_id: str = "skill:local", *, variant: str = "load", ) -> dict[str, object]: identity = _catalog_identity(capability_id, namespace=f"catalog-namespace:{variant}") material = _material(capability_id, variant) descriptor = MaterialDescriptor.create( capability_id=capability_id, kind=capability_id.split(":", 1)[0], actionability="load", content_sha256=material.content_sha256, content_bytes=material.content_bytes, estimated_tokens=8, provenance_digest=_digest(f"catalog-snapshot:{variant}"), material_identity_digest=material.identity_digest, ) authorized = AuthorizedMaterial.from_catalog( catalog_identity_digest=identity.identity_digest, descriptor=descriptor, ) return { **_presentation(capability_id, "load"), "catalog_identity": identity.to_dict(), "benefit": _benefit(), "authority": {"type": "load", "material": authorized.to_dict()}, } def _install_row(capability_id: str = "skill:remote") -> dict[str, object]: identity = _catalog_identity(capability_id) result_material = _material(capability_id, "install") descriptor = InstallPlanDescriptor.create( capability_id=capability_id, kind=capability_id.split(":", 1)[0], installer_id="skill-installer", plan_digest=_digest(f"plan:{capability_id}"), provenance_digest=_digest("install-snapshot"), result_material_identity_digest=result_material.identity_digest, ) presentation = _presentation(capability_id, "install") presentation["install_descriptor_digest"] = descriptor.descriptor_digest presentation["install_plan_digest"] = descriptor.plan_digest return { **presentation, "catalog_identity": identity.to_dict(), "benefit": _benefit(), "authority": { "type": "install", "descriptor": descriptor.to_dict(), "result_material": result_material.to_dict(), }, } def _manual_row(capability_id: str = "agent:advisor") -> dict[str, object]: return { **_presentation(capability_id, "manual"), "catalog_identity": _catalog_identity(capability_id).to_dict(), "benefit": _benefit("advisory"), "authority": {"type": "manual"}, } def _audit( *, candidate_pool_count: int = 3, search_evaluation_count: int = 9, ) -> dict[str, object]: return { "result_schema_id": "ctx.benefit-selection-result-v1", "result_digest": _digest("benefit-result"), "policy_schema_id": "ctx.net-benefit-policy-v3", "policy_digest": _digest("benefit-policy"), "selection_algorithm_id": "ctx.greedy-bounded-subset-exchange-v1", "calibration_digest": _digest("calibration"), "requested_limit": 5, "candidate_pool_count": candidate_pool_count, "search_evaluation_count": search_evaluation_count, } def _plan() -> StructuredSurrogate: return StructuredSurrogate.create( schema_id="ctx.decision.capability-plan", schema_version=3, value={ "status": "ready", "abstention_code": None, "benefit_audit": _audit(), "capabilities": [_load_row(), _install_row(), _manual_row()], }, ) def _single_install_plan(capability_id: str) -> StructuredSurrogate: return StructuredSurrogate.create( schema_id="ctx.decision.capability-plan", schema_version=3, value={ "status": "ready", "abstention_code": None, "benefit_audit": _audit( candidate_pool_count=1, search_evaluation_count=1, ), "capabilities": [_install_row(capability_id)], }, ) def _degraded_plan() -> StructuredSurrogate: return StructuredSurrogate.create( schema_id="ctx.decision.capability-plan", schema_version=3, value={ "status": "degraded", "abstention_code": "planner-failed", "benefit_audit": None, "capabilities": [], }, ) def _actions(transition: object, kind: str) -> tuple[HostAction, ...]: actions = getattr(transition, "actions") return tuple(action for action in actions if action.kind == kind) def _started_and_planned(): state, _ = reduce_replay_v3( None, _replay(_event("SessionStarted", 0, "start", payload={"host_level": "managing"})), ) return reduce_replay_v3( state, _replay(_event("IntentObserved", 1, "plan"), decision=_plan()), ) def _desired_row(row: Mapping[str, object], lease_id: str) -> dict[str, object]: return { "capability_id": row["capability_id"], "source_digest": row["catalog_entry_digest"], "kind": row["kind"], "actionability": row["actionability"], "install_descriptor_digest": row["install_descriptor_digest"], "install_plan_digest": row["install_plan_digest"], "lease_id": lease_id, } def _install_requested(): state, _ = _started_and_planned() event = _event( "ReassessmentRequested", state.revision, "desired", payload={ "owner_id": "owner-1", "policy_snapshot_digest": POLICY_DIGEST, "desired_capabilities": [ _desired_row(_load_row(), "lease-load"), _desired_row(_install_row(), "lease-install"), ], }, ) return reduce_replay_v3(state, _replay(event)) def _single_install_requested(capability_id: str): state, _ = reduce_replay_v3( None, _replay(_event("SessionStarted", 0, "start", payload={"host_level": "managing"})), ) state, _ = reduce_replay_v3( state, _replay( _event("IntentObserved", 1, "plan"), decision=_single_install_plan(capability_id), ), ) event = _event( "ReassessmentRequested", state.revision, "desired", payload={ "owner_id": "owner-1", "policy_snapshot_digest": POLICY_DIGEST, "desired_capabilities": [ _desired_row(_install_row(capability_id), "lease-install"), ], }, ) return reduce_replay_v3(state, _replay(event)) @pytest.mark.parametrize( "event_kind", ["ProviderSubmissionObserved", "ToolCallObserved", "TurnStarting"], ) def test_schema3_actionless_revision_reoffers_consumed_install_consent( event_kind: str, ) -> None: capability_id = "skill:remote" state, requested = _single_install_requested(capability_id) original = _actions(requested, "RequestConsent")[0] payload: Mapping[str, object] if event_kind == "ProviderSubmissionObserved": payload = {"capabilities": []} elif event_kind == "ToolCallObserved": payload = { "capability_id": capability_id, "source_digest": _install_row(capability_id)["catalog_entry_digest"], "outcome": "failed", } else: payload = {} state, transition = reduce_replay_v3( state, _replay( _event( event_kind, state.revision, f"consume-consent-{event_kind}", payload=payload, ) ), ) refreshed = _actions(transition, "RequestConsent") assert len(refreshed) == 1 assert refreshed[0].action_id != original.action_id assert refreshed[0].entity_id == capability_id assert len(state.pending_consents) == 1 assert state.pending_consents[0].consent_id == refreshed[0].consent_id assert ( state.pending_consents[0].install_action.action_id == refreshed[0].payload["requested_action_id"] ) def _decision_for(request: HostAction) -> EngineEvent: return _event( "UserDecision", request.precondition_revision, "grant", payload={ "consent_id": request.consent_id or "", "decision": "granted", "decision_basis": "interactive", "policy_snapshot_digest": 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 _receipt_event(state, action: HostAction, verification: Mapping[str, object]) -> EngineEvent: return _event( "ActionApplied", state.revision, f"receipt-{action.kind}", scope=action.scope, payload={ "action_id": action.action_id, "action_kind": action.kind, "action_content_digest": action.content_digest, "action_precondition_revision": action.precondition_revision, "verification": verification, }, ) def _material_receipt_verification(action: HostAction) -> dict[str, object]: return { "schema": MATERIAL_RECEIPT_SCHEMA_V3, "host_state": action.verification["expected_state"], "capability_id": action.entity_id, "capability_kind": action.payload["capability_kind"], "catalog_identity": action.payload["catalog_identity"], "material_identity": action.payload["material_identity"], "authorized_material": action.payload["authorized_material"], } def _install_receipt_verification( capability: CapabilityStateV3, action: HostAction, ) -> dict[str, object]: authority = capability.selection.authority assert isinstance(authority, InstallPlanningAuthority) return { "schema": INSTALL_RECEIPT_SCHEMA_V3, "host_state": "installed", "capability_id": capability.capability_id, "capability_kind": capability.kind, "catalog_identity": capability.catalog_identity.to_dict(), "material_identity": capability.material_identity.to_dict(), "install_plan_descriptor": authority.descriptor.to_dict(), "installer_digest": action.payload["installer_digest"], "policy_snapshot_digest": POLICY_DIGEST, } def _prompt_context_receipt_verification(action: HostAction) -> dict[str, object]: rows = action.payload["capabilities"] assert isinstance(rows, tuple) context = b"bounded prepared prompt context" return { "schema": PROMPT_CONTEXT_RECEIPT_SCHEMA_V1, "host_state": "prompt-context-prepared", "prompt_context_sha256": hashlib.sha256(context).hexdigest(), "prompt_context_bytes": len(context), "capabilities": [ { "capability_id": row["capability_id"], "content_sha256": row["material_identity"]["content_sha256"], "content_bytes": row["material_identity"]["content_bytes"], } for row in rows ], } def _active_installed_remote_state( capability_id: str = "skill:remote", ) -> EngineState: state, requested = _single_install_requested(capability_id) request = _actions(requested, "RequestConsent")[0] state, granted = reduce_replay_v3(state, _replay(_decision_for(request))) install = _actions(granted, "InstallCapability")[0] capability = state.capability(capability_id) assert isinstance(capability, CapabilityStateV3) state, activation_requested = reduce_replay_v3( state, _replay( _receipt_event( state, install, _install_receipt_verification(capability, install), ) ), ) activate = _actions(activation_requested, "ActivateCapability")[0] state, _ = reduce_replay_v3( state, _replay( _receipt_event( state, activate, _material_receipt_verification(activate), ) ), ) return state def test_schema3_prepares_one_prompt_context_without_faking_activation() -> None: state, _ = reduce_replay_v4( None, _replay_v4( _event( "SessionStarted", 0, "prompt-start", payload={"host_level": "prompt-context-activate"}, ) ), ) state, requested = reduce_replay_v4( state, _replay_v4(_event("IntentObserved", 1, "prompt-plan"), decision=_plan()), ) capability = state.capability("skill:local") assert isinstance(capability, CapabilityStateV3) assert capability.activation == "inactive" assert capability.leases == () plan = state.committed_plan assert isinstance(plan, CommittedPlanV3) actions = _actions(requested, "PreparePromptContext") assert len(actions) == 1 action = actions[0] assert tuple(item.kind for item in requested.actions) == ( "PresentBundle", "PreparePromptContext", ) assert action.required_host_feature == "prompt-context" assert action.entity_id is None assert tuple(row["capability_id"] for row in action.payload["capabilities"]) == ("skill:local",) assert action.lease_id is not None assert tuple(item.effect for item in state.pending_effects) == ("prompt-context",) still_inactive = state.capability("skill:local") assert isinstance(still_inactive, CapabilityStateV3) assert still_inactive.activation == "inactive" assert still_inactive.leases == () state, completed = reduce_replay_v4( state, _replay_v4( _receipt_event( state, action, _prompt_context_receipt_verification(action), ) ), ) assert completed.actions == () assert state.pending_effects == () assert state.evidence_for(action.scope.exposure_id, "skill:local").exposure == "prepared" completed_capability = state.capability("skill:local") assert isinstance(completed_capability, CapabilityStateV3) assert completed_capability.activation == "inactive" assert completed_capability.leases == () def test_schema3_prompt_context_is_absent_without_explicit_activating_host() -> None: state, _ = reduce_replay_v4( None, _replay_v4( _event("SessionStarted", 0, "query-start", payload={"host_level": "query-only"}) ), ) state, planned = reduce_replay_v4( state, _replay_v4(_event("IntentObserved", 1, "query-plan"), decision=_plan()), ) assert _actions(planned, "PreparePromptContext") == () assert state.pending_effects == () def _promoted_load_row( capability: CapabilityStateV3, material: AuthorizedMaterial, ) -> dict[str, object]: presentation = _presentation(capability.capability_id, "load") presentation["catalog_entry_digest"] = capability.source_digest return { **presentation, "catalog_identity": capability.catalog_identity.to_dict(), "benefit": _benefit(), "authority": {"type": "load", "material": material.to_dict()}, } def _catalog_material_for_installed( capability: CapabilityStateV3, ) -> AuthorizedMaterial: material = capability.material_identity descriptor = MaterialDescriptor.create( capability_id=capability.capability_id, kind=capability.kind, actionability="load", content_sha256=material.content_sha256, content_bytes=material.content_bytes, estimated_tokens=8, provenance_digest=_digest("refreshed-catalog-snapshot"), material_identity_digest=material.identity_digest, ) return AuthorizedMaterial.from_catalog( catalog_identity_digest=capability.catalog_identity.identity_digest, descriptor=descriptor, ) def test_schema3_plan_persists_exact_audit_and_authority_without_manual_lifecycle() -> None: state, transition = _started_and_planned() assert isinstance(state.committed_plan, CommittedPlanV3) assert state.committed_plan.benefit_audit is not None assert state.committed_plan.benefit_audit.to_mapping() == _audit() assert [item.to_dict() for item in state.committed_plan.capabilities] == [ _load_row(), _install_row(), _manual_row(), ] assert state.last_manual_bundle == ("agent:advisor",) assert {item.capability_id for item in state.capabilities} == {"skill:local", "skill:remote"} load = state.capability("skill:local") install = state.capability("skill:remote") assert isinstance(load, CapabilityStateV3) assert isinstance(load.selection.authority, LoadPlanningAuthority) assert load.installation == "installed" assert load.current_authorized_material == load.selection.authority.material assert isinstance(install, CapabilityStateV3) assert isinstance(install.selection.authority, InstallPlanningAuthority) assert install.installation == "absent" assert install.current_authorized_material is None assert install.material_identity == install.selection.authority.result_material bundle = _actions(transition, "PresentBundle")[0] assert [item["capability_id"] for item in bundle.payload["capabilities"]] == [ "skill:local", "skill:remote", "agent:advisor", ] @pytest.mark.parametrize("capability_id", INSTALLABLE_CAPABILITY_IDS) def test_schema3_install_receipt_promotes_exact_lineage_then_reconciles_activation( capability_id: str, ) -> None: state, requested = _single_install_requested(capability_id) request = _actions(requested, "RequestConsent")[0] assert request.payload["schema"] == "ctx.install-consent-request-v3" state, granted = reduce_replay_v3(state, _replay(_decision_for(request))) install = _actions(granted, "InstallCapability")[0] assert install.verification["receipt_schema"] == INSTALL_RECEIPT_SCHEMA_V3 capability = state.capability(capability_id) assert isinstance(capability, CapabilityStateV3) authority = capability.selection.authority assert isinstance(authority, InstallPlanningAuthority) verification = { "schema": INSTALL_RECEIPT_SCHEMA_V3, "host_state": "installed", "capability_id": capability.capability_id, "capability_kind": capability.kind, "catalog_identity": capability.catalog_identity.to_dict(), "material_identity": capability.material_identity.to_dict(), "install_plan_descriptor": authority.descriptor.to_dict(), "installer_digest": install.payload["installer_digest"], "policy_snapshot_digest": POLICY_DIGEST, } receipt = _receipt_event(state, install, verification) state, transition = reduce_replay_v3(state, _replay(receipt)) capability = state.capability(capability_id) assert isinstance(capability, CapabilityStateV3) assert capability.installation == "installed" assert capability.current_authorized_material is not None lineage = capability.current_authorized_material.installed_material_lineage assert lineage is not None assert lineage.install_action_content_digest == install.content_digest assert lineage.install_receipt_content_digest == receipt.content_digest activate = next( action for action in _actions(transition, "ActivateCapability") if action.entity_id == capability_id ) assert ( activate.payload["authorized_material"] == capability.current_authorized_material.to_dict() ) assert activate.verification["receipt_schema"] == MATERIAL_RECEIPT_SCHEMA_V3 @pytest.mark.parametrize( ("capability_id", "substituted_capability_id"), [ ("skill:remote", "agent:foreign"), ("agent:reviewer", "mcp-server:foreign"), ("mcp-server:repository-tools", "skill:foreign"), ], ) def test_schema3_receipt_rejects_typed_substitution_before_promotion( capability_id: str, substituted_capability_id: str, ) -> None: state, requested = _single_install_requested(capability_id) request = _actions(requested, "RequestConsent")[0] state, granted = reduce_replay_v3(state, _replay(_decision_for(request))) install = _actions(granted, "InstallCapability")[0] capability = state.capability(capability_id) assert isinstance(capability, CapabilityStateV3) authority = capability.selection.authority assert isinstance(authority, InstallPlanningAuthority) wrong_identity = _catalog_identity(substituted_capability_id) verification = { "schema": INSTALL_RECEIPT_SCHEMA_V3, "host_state": "installed", "capability_id": capability.capability_id, "capability_kind": capability.kind, "catalog_identity": wrong_identity.to_dict(), "material_identity": capability.material_identity.to_dict(), "install_plan_descriptor": authority.descriptor.to_dict(), "installer_digest": install.payload["installer_digest"], "policy_snapshot_digest": POLICY_DIGEST, } with pytest.raises((InvalidEventError, ValueError)): receipt = _receipt_event(state, install, verification) reduce_replay_v3(state, _replay(receipt)) unchanged = state.capability(capability_id) assert isinstance(unchanged, CapabilityStateV3) assert unchanged.installation == "absent" assert unchanged.current_authorized_material is None def test_schema3_degraded_plan_preserves_exact_runtime_authority_and_leases() -> None: state, _ = _install_requested() runtime_before = ( state.capabilities, state.pending_effects, state.pending_consents, state.evidence, state.blocked_capability_ids, state.blocked_deactivation_ids, state.blocked_install_descriptor_digests, state.install_policy_snapshot_digest, state.rollback_requested_capability_ids, state.terminal_cleanup_notified_ids, ) state, transition = reduce_replay_v3( state, _replay( _event( "IntentObserved", state.revision, "degraded", correlation_id="plan-degraded-v3", ), decision=_degraded_plan(), ), ) assert isinstance(state.committed_plan, CommittedPlanV3) assert state.committed_plan.status == "degraded" assert state.last_manual_bundle == () assert not transition.actions assert {item["code"] for item in transition.diagnostics} == {"planner-failed"} assert ( state.capabilities, state.pending_effects, state.pending_consents, state.evidence, state.blocked_capability_ids, state.blocked_deactivation_ids, state.blocked_install_descriptor_digests, state.install_policy_snapshot_digest, state.rollback_requested_capability_ids, state.terminal_cleanup_notified_ids, ) == runtime_before def test_schema3_rejects_same_id_authority_change_while_old_material_is_active() -> None: state, _ = _started_and_planned() state, requested = reduce_replay_v3( state, _replay( _event( "ReassessmentRequested", state.revision, "activate-old", payload={ "owner_id": "owner-old", "policy_snapshot_digest": POLICY_DIGEST, "desired_capabilities": [_desired_row(_load_row(), "lease-old-material")], }, ) ), ) activate = _actions(requested, "ActivateCapability")[0] state, _ = reduce_replay_v3( state, _replay( _receipt_event( state, activate, _material_receipt_verification(activate), ) ), ) original = state.capability("skill:local") assert isinstance(original, CapabilityStateV3) assert original.activation == "active" original_authority = original.current_authorized_material changed = _load_row(variant="changed-material") changed["catalog_entry_digest"] = _digest("entry:skill:local:changed") changed_plan = StructuredSurrogate.create( schema_id="ctx.decision.capability-plan", schema_version=3, value={ "status": "ready", "abstention_code": None, "benefit_audit": _audit( candidate_pool_count=1, search_evaluation_count=1, ), "capabilities": [changed], }, ) with pytest.raises(InvalidEventError, match="prior same-ID runtime authority"): reduce_replay_v3( state, _replay( _event( "IntentObserved", state.revision, "changed-same-id", correlation_id="plan-changed-same-id", ), decision=changed_plan, ), ) still_active = state.capability("skill:local") assert isinstance(still_active, CapabilityStateV3) assert still_active.activation == "active" assert still_active.current_authorized_material == original_authority @pytest.mark.parametrize("capability_id", INSTALLABLE_CAPABILITY_IDS) def test_schema3_promotes_exact_installed_material_to_load_without_runtime_churn( capability_id: str, ) -> None: state = _active_installed_remote_state(capability_id) state, _ = reduce_replay_v3( state, _replay( _event( "ToolCallObserved", state.revision, "observe-installed-remote", payload={ "capability_id": capability_id, "source_digest": _install_row(capability_id)["catalog_entry_digest"], "outcome": "succeeded", }, ) ), ) before = state.capability(capability_id) assert isinstance(before, CapabilityStateV3) assert before.activation == "active" assert before.current_authorized_material is not None assert before.installed_lineage is not None evidence_before = state.evidence refreshed_catalog_material = _catalog_material_for_installed(before) promoted_row = _promoted_load_row(before, refreshed_catalog_material) promoted_plan = StructuredSurrogate.create( schema_id="ctx.decision.capability-plan", schema_version=3, value={ "status": "ready", "abstention_code": None, "benefit_audit": _audit(), "capabilities": [promoted_row], }, ) state, _ = reduce_replay_v3( state, _replay( _event( "IntentObserved", state.revision, "promote-installed-remote", correlation_id="plan-promote-installed-remote", ), decision=promoted_plan, ), ) promoted = state.capability(capability_id) assert isinstance(promoted, CapabilityStateV3) assert isinstance(promoted.selection.authority, LoadPlanningAuthority) assert promoted.activation == before.activation assert promoted.activation_lease_id == before.activation_lease_id assert promoted.leases == before.leases assert promoted.material_identity == before.material_identity assert promoted.current_authorized_material == refreshed_catalog_material assert promoted.source_digest == before.source_digest assert state.evidence == evidence_before assert EngineState.from_json(state.to_json()) == state def test_schema3_rejects_install_to_load_promotion_with_changed_material() -> None: state = _active_installed_remote_state() current = state.capability("skill:remote") assert isinstance(current, CapabilityStateV3) assert current.current_authorized_material is not None changed_identity = _material("skill:remote", "changed-after-install") changed_descriptor = MaterialDescriptor.create( capability_id="skill:remote", kind="skill", actionability="load", content_sha256=changed_identity.content_sha256, content_bytes=changed_identity.content_bytes, estimated_tokens=8, provenance_digest=_digest("changed-after-install-snapshot"), material_identity_digest=changed_identity.identity_digest, ) changed_material = AuthorizedMaterial.from_catalog( catalog_identity_digest=current.catalog_identity.identity_digest, descriptor=changed_descriptor, ) changed_plan = StructuredSurrogate.create( schema_id="ctx.decision.capability-plan", schema_version=3, value={ "status": "ready", "abstention_code": None, "benefit_audit": _audit(), "capabilities": [_promoted_load_row(current, changed_material)], }, ) with pytest.raises(InvalidEventError, match="prior same-ID runtime authority"): reduce_replay_v3( state, _replay( _event( "IntentObserved", state.revision, "reject-changed-promotion-material", correlation_id="plan-reject-changed-promotion-material", ), decision=changed_plan, ), ) unchanged = state.capability("skill:remote") assert isinstance(unchanged, CapabilityStateV3) assert isinstance(unchanged.selection.authority, InstallPlanningAuthority) assert unchanged.activation == "active" assert EngineState.from_json(state.to_json()) == state def test_schema3_defers_overlapping_exposure_prepare_until_prior_receipt() -> None: state, _ = _started_and_planned() state, requested = reduce_replay_v3( state, _replay( _event( "ReassessmentRequested", state.revision, "activate-parent", payload={ "owner_id": "owner-parent", "policy_snapshot_digest": POLICY_DIGEST, "desired_capabilities": [_desired_row(_load_row(), "lease-parent")], }, ) ), ) activate = _actions(requested, "ActivateCapability")[0] state, _ = reduce_replay_v3( state, _replay( _receipt_event( state, activate, _material_receipt_verification(activate), ) ), ) child_scope = _scope(exposure_id="exposure-child") state, _ = reduce_replay_v3( state, _replay( _event( "ReassessmentRequested", state.revision, "lease-child", scope=child_scope, payload={ "owner_id": "owner-child", "policy_snapshot_digest": POLICY_DIGEST, "desired_capabilities": [_desired_row(_load_row(), "lease-child")], }, ) ), ) state, parent_prepare = reduce_replay_v3( state, _replay(_event("TurnStarting", state.revision, "prepare-parent")), ) prepare = _actions(parent_prepare, "PrepareExposure")[0] state, child_deferred = reduce_replay_v3( state, _replay( _event( "TurnStarting", state.revision, "prepare-child", scope=child_scope, ) ), ) assert not _actions(child_deferred, "PrepareExposure") assert len(state.pending_effects) == 1 assert state.pending_effects[0].action == prepare def test_schema3_exact_deactivation_receipt_prunes_retired_row_before_persistence() -> None: state, _ = _started_and_planned() state, requested = reduce_replay_v3( state, _replay( _event( "ReassessmentRequested", state.revision, "activate-before-retirement", payload={ "owner_id": "owner-retirement", "policy_snapshot_digest": POLICY_DIGEST, "desired_capabilities": [_desired_row(_load_row(), "lease-retirement")], }, ) ), ) activate = _actions(requested, "ActivateCapability")[0] state, _ = reduce_replay_v3( state, _replay( _receipt_event( state, activate, _material_receipt_verification(activate), ) ), ) retirement_plan = StructuredSurrogate.create( schema_id="ctx.decision.capability-plan", schema_version=3, value={ "status": "ready", "abstention_code": None, "benefit_audit": _audit(), "capabilities": [_manual_row()], }, ) state, cooling = reduce_replay_v3( state, _replay( _event( "IntentObserved", state.revision, "retire-load", correlation_id="plan-retire-load", ), decision=retirement_plan, ), ) deactivate = _actions(cooling, "DeactivateCapability")[0] state, _ = reduce_replay_v3( state, _replay( _receipt_event( state, deactivate, _material_receipt_verification(deactivate), ) ), ) assert state.capability("skill:local") is None assert EngineState.from_json(state.to_json()) == state