from __future__ import annotations import hashlib import json from collections.abc import Mapping from dataclasses import fields, replace import pytest from ctx.engine.content import MaterialIdentity from ctx.engine.installation import ( InstallConsentRoutingError, InstallConsentPolicy, InstallPlanningBundle, InstallPlanDescriptor, PreparedInstallPlan, route_install_authorization, route_install_consent_request, ) from ctx.engine.lineage import CatalogCapabilityIdentity from ctx.engine.planner import CapabilityCandidate, CapabilitySelection from ctx.engine.planning_v3 import ( CapabilityBenefitProjection, CapabilityPlanSelectionV3, InstallPlanningAuthority, ) from ctx.engine.protocol import EngineEvent, HostAction, ScopeRef from ctx.engine.reducer import reduce_replay_v3 from ctx.engine.replay import ReplayInput, StructuredSurrogate from ctx.engine.state import CommittedPlanV3 INSTALLABLE_CAPABILITY_CASES = ( ("skill:python-testing", "skill"), ("agent:reviewer", "agent"), ("mcp-server:repository-tools", "mcp-server"), ) NOW = "2026-08-02T12:00:00Z" def _digest(label: str) -> str: return hashlib.sha256(label.encode()).hexdigest() def _descriptor( *, capability_id: str = "skill:python-testing", kind: str = "skill", permission_expansion: bool = False, credential_requirement: bool = False, ) -> InstallPlanDescriptor: return InstallPlanDescriptor.create( capability_id=capability_id, kind=kind, installer_id="ctx-builtin-installer-v1", plan_digest=_digest("plan"), provenance_digest=_digest("provenance"), permission_expansion=permission_expansion, credential_requirement=credential_requirement, ) def _prepared( descriptor: InstallPlanDescriptor, policy: InstallConsentPolicy, **overrides: object, ) -> PreparedInstallPlan: values: dict[str, object] = { "capability_id": descriptor.capability_id, "kind": descriptor.kind, "installer_id": descriptor.installer_id, "action_id": "install-action-1", "action_content_digest": _digest("action"), "selection_source_digest": _digest("selection"), "catalog_snapshot_digest": _digest("catalog"), "plan_digest": descriptor.plan_digest, "provenance_digest": descriptor.provenance_digest, "descriptor_digest": descriptor.descriptor_digest, "consent_policy_digest": policy.policy_digest, "execution_token": "ephemeral-install-1", "permission_expansion": descriptor.permission_expansion, "credential_requirement": descriptor.credential_requirement, } values.update(overrides) return PreparedInstallPlan(**values) # type: ignore[arg-type] def _selection(descriptor: InstallPlanDescriptor) -> CapabilitySelection: return CapabilitySelection( capability_id=descriptor.capability_id, kind=descriptor.kind, name=descriptor.capability_id.split(":", 1)[1], source_digest=_digest("selection"), normalized_score_ppm=900_000, matching_signals=("python", "testing"), reason_codes=("exact-tag-match",), actionability="install", install_descriptor_digest=descriptor.descriptor_digest, install_plan_digest=descriptor.plan_digest, ) def _request( descriptor: InstallPlanDescriptor, policy: InstallConsentPolicy, ) -> HostAction: selection = _selection(descriptor) return HostAction( action_id="request-consent-1", kind="RequestConsent", scope=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-1", ), precondition_revision=3, entity_id=selection.capability_id, source_digest=selection.source_digest, plan_id="plan-1", catalog_snapshot_id=_digest("catalog"), consent_id="consent-1", required_host_feature="installation-consent", payload={ "install_descriptor_digest": descriptor.descriptor_digest, "install_plan_digest": descriptor.plan_digest, "installer_id": "ctx-install-plan-executor-v1", "installer_digest": _digest("executor"), "policy_snapshot_digest": policy.policy_digest, "requested_action_id": "install-action-1", "requested_action_kind": "InstallCapability", "requested_action_content_digest": _digest("install-action"), "requested_action_precondition_revision": 4, }, ) def _policy_for_kind(kind: str, mode: str) -> InstallConsentPolicy: modes = { "skill_mode": "ask-each-time", "agent_mode": "ask-each-time", "mcp_server_mode": "ask-each-time", } modes[ { "skill": "skill_mode", "agent": "agent_mode", "mcp-server": "mcp_server_mode", }[kind] ] = mode return InstallConsentPolicy(**modes) # type: ignore[arg-type] def _v3_event( kind: str, revision: int, event_id: str, *, payload: Mapping[str, object] | None = None, ) -> EngineEvent: return EngineEvent( event_id=event_id, kind=kind, scope=ScopeRef( tenant_id="tenant-1", workspace_id="workspace-1", repository_id="repository-1", session_id="session-v3", exposure_id="exposure-v3", host_context_id="host-v3", ), expected_revision=revision, occurred_at=NOW, payload={} if payload is None else payload, correlation_id="plan-v3", engine_version="engine-v3", planner_version="planner-v3", policy_version="policy-v3", host_descriptor_digest=_digest("v3-host"), catalog_snapshot_digest=_digest("v3-catalog"), semantic_model_digest=_digest("v3-model"), semantic_index_digest=_digest("v3-index"), work_signature=_digest("v3-work"), random_seed=17, ) def _v3_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 _reducer_v3_consent_request( capability_id: str, policy: InstallConsentPolicy, *, permission_expansion: bool = False, credential_requirement: bool = False, ) -> tuple[HostAction, CapabilityPlanSelectionV3, InstallPlanDescriptor]: kind, name = capability_id.split(":", 1) source_digest = _digest(f"v3-entry:{capability_id}") material = MaterialIdentity.create( capability_id=capability_id, kind=kind, content_sha256=_digest(f"v3-content:{capability_id}"), content_bytes=128, ) descriptor = InstallPlanDescriptor.create( capability_id=capability_id, kind=kind, installer_id=f"ctx-{kind}-installer-v1", plan_digest=_digest(f"v3-plan:{capability_id}"), provenance_digest=_digest(f"v3-provenance:{capability_id}"), permission_expansion=permission_expansion, credential_requirement=credential_requirement, result_material_identity_digest=material.identity_digest, ) selection = CapabilityPlanSelectionV3( presentation=CapabilityCandidate( capability_id=capability_id, kind=kind, name=name, source_digest=source_digest, normalized_score_ppm=900_000, matching_signals=("python",), reason_codes=("signal-match",), actionability="install", install_descriptor_digest=descriptor.descriptor_digest, install_plan_digest=descriptor.plan_digest, ), catalog_identity=CatalogCapabilityIdentity.create( capability_id=capability_id, kind=kind, catalog_namespace_digest=_digest("v3-catalog-namespace"), ), benefit=CapabilityBenefitProjection( tier="executable", individual_net_benefit_u=600_000, marginal_net_benefit_u=600_000, ), authority=InstallPlanningAuthority( descriptor=descriptor, result_material=material, ), ) plan = StructuredSurrogate.create( schema_id="ctx.decision.capability-plan", schema_version=3, value={ "status": "ready", "abstention_code": None, "benefit_audit": { "result_schema_id": "ctx.benefit-selection-result-v1", "result_digest": _digest(f"v3-benefit-result:{capability_id}"), "policy_schema_id": "ctx.net-benefit-policy-v3", "policy_digest": _digest("v3-benefit-policy"), "selection_algorithm_id": "ctx.greedy-bounded-subset-exchange-v1", "calibration_digest": _digest("v3-calibration"), "requested_limit": 5, "candidate_pool_count": 1, "search_evaluation_count": 1, }, "capabilities": [selection.to_mapping()], }, ) state, _ = reduce_replay_v3( None, _v3_replay( _v3_event( "SessionStarted", 0, f"start-{kind}", payload={"host_level": "managing"}, ) ), ) state, _ = reduce_replay_v3( state, _v3_replay( _v3_event("IntentObserved", 1, f"plan-{kind}"), decision=plan, ), ) state, transition = reduce_replay_v3( state, _v3_replay( _v3_event( "ReassessmentRequested", 2, f"desired-{kind}", payload={ "owner_id": "owner-1", "policy_snapshot_digest": policy.policy_digest, "desired_capabilities": [ { "capability_id": capability_id, "source_digest": source_digest, "lease_id": f"lease-{kind}", "kind": kind, "actionability": "install", "install_descriptor_digest": descriptor.descriptor_digest, "install_plan_digest": descriptor.plan_digest, } ], }, ) ), ) requests = tuple(action for action in transition.actions if action.kind == "RequestConsent") assert len(requests) == 1 assert isinstance(state.committed_plan, CommittedPlanV3) committed_selection = state.committed_plan.capabilities[0].selection return requests[0], committed_selection, descriptor def test_descriptor_has_canonical_round_trip_and_rejects_digest_tamper() -> None: descriptor = _descriptor() assert InstallPlanDescriptor.from_dict(descriptor.to_dict()) == descriptor assert descriptor.recomputed_descriptor_digest == descriptor.descriptor_digest tampered = descriptor.to_dict() tampered["plan_digest"] = _digest("different-plan") with pytest.raises(ValueError, match="descriptor_digest"): InstallPlanDescriptor.from_dict(tampered) tampered_risk = descriptor.to_dict() tampered_risk["permission_expansion"] = True with pytest.raises(ValueError, match="descriptor_digest"): InstallPlanDescriptor.from_dict(tampered_risk) def test_v1_descriptor_bytes_remain_frozen_without_result_material() -> None: descriptor = _descriptor() encoded = json.dumps( descriptor.to_dict(), ensure_ascii=True, allow_nan=False, separators=(",", ":"), sort_keys=True, ) assert encoded == ( '{"capability_id":"skill:python-testing","credential_requirement":false,' '"descriptor_digest":"2571612ff39e615a258f9632a346aae775c5d81afa754cf4095b559b40eaeaa6",' '"installer_id":"ctx-builtin-installer-v1","kind":"skill",' '"permission_expansion":false,' '"plan_digest":"64879f7d6b960a01909762d911a32d4582c20010c5641ee90278b644a9e3b525",' '"provenance_digest":"96d815328a42cb4ef89d5e0b7a1df6be43b484832c83a7b4596d8402c7c0b12b",' '"rollback_strategy":"atomic-restore",' '"schema":"ctx.install-plan-descriptor-v1","target_scope":"user"}' ) assert InstallPlanDescriptor.from_dict(json.loads(encoded)).to_dict() == descriptor.to_dict() def test_v2_descriptor_binds_exact_result_material_identity() -> None: first = InstallPlanDescriptor.create( capability_id="skill:python-testing", kind="skill", installer_id="ctx-builtin-installer-v1", plan_digest=_digest("plan"), provenance_digest=_digest("provenance"), result_material_identity_digest=_digest("material-one"), ) second = InstallPlanDescriptor.create( capability_id="skill:python-testing", kind="skill", installer_id="ctx-builtin-installer-v1", plan_digest=_digest("plan"), provenance_digest=_digest("provenance"), result_material_identity_digest=_digest("material-two"), ) assert first.schema_version == 2 assert first.result_material_identity_digest == _digest("material-one") assert first.descriptor_digest != second.descriptor_digest assert InstallPlanDescriptor.from_dict(first.to_dict()) == first substituted = first.to_dict() assert second.result_material_identity_digest is not None substituted["result_material_identity_digest"] = second.result_material_identity_digest with pytest.raises(ValueError, match="descriptor_digest"): InstallPlanDescriptor.from_dict(substituted) policy = InstallConsentPolicy() prepared = _prepared( first, policy, result_material_identity_digest=first.result_material_identity_digest, ) assert prepared.matches_descriptor(first) assert not replace( prepared, result_material_identity_digest=second.result_material_identity_digest, ).matches_descriptor(first) @pytest.mark.parametrize(("capability_id", "kind"), INSTALLABLE_CAPABILITY_CASES) def test_v2_result_material_contract_supports_every_installable_kind( capability_id: str, kind: str, ) -> None: material = MaterialIdentity.create( capability_id=capability_id, kind=kind, content_sha256=_digest(f"content:{capability_id}"), content_bytes=128, ) descriptor = InstallPlanDescriptor.create( capability_id=capability_id, kind=kind, installer_id="ctx-builtin-installer-v1", plan_digest=_digest(f"plan:{capability_id}"), provenance_digest=_digest(f"provenance:{capability_id}"), result_material_identity_digest=material.identity_digest, ) policy = InstallConsentPolicy() prepared = _prepared( descriptor, policy, result_material_identity_digest=material.identity_digest, ) assert InstallPlanDescriptor.from_dict(descriptor.to_dict()) == descriptor assert ( InstallPlanningBundle( descriptor=descriptor, result_material=material, ).result_material == material ) assert prepared.matches_descriptor(descriptor) @pytest.mark.parametrize( ("descriptor_capability_id", "descriptor_kind", "material_capability_id", "material_kind"), [ ("skill:python-testing", "skill", "agent:reviewer", "agent"), ("agent:reviewer", "agent", "mcp-server:repository-tools", "mcp-server"), ("mcp-server:repository-tools", "mcp-server", "skill:python-testing", "skill"), ], ) def test_v2_bundle_rejects_cross_kind_result_material_substitution( descriptor_capability_id: str, descriptor_kind: str, material_capability_id: str, material_kind: str, ) -> None: substituted_material = MaterialIdentity.create( capability_id=material_capability_id, kind=material_kind, content_sha256=_digest(f"content:{material_capability_id}"), content_bytes=128, ) descriptor = InstallPlanDescriptor.create( capability_id=descriptor_capability_id, kind=descriptor_kind, installer_id="ctx-builtin-installer-v1", plan_digest=_digest(f"plan:{descriptor_capability_id}"), provenance_digest=_digest(f"provenance:{descriptor_capability_id}"), result_material_identity_digest=substituted_material.identity_digest, ) assert not descriptor.matches_result_material(substituted_material) with pytest.raises(ValueError, match="result material"): InstallPlanningBundle( descriptor=descriptor, result_material=substituted_material, ) def test_v2_descriptor_matches_only_the_exact_typed_result_material() -> None: material = MaterialIdentity.create( capability_id="skill:python-testing", kind="skill", content_sha256=_digest("content"), content_bytes=128, ) descriptor = InstallPlanDescriptor.create( capability_id=material.capability_id, kind=material.kind, installer_id="ctx-builtin-installer-v1", plan_digest=_digest("plan"), provenance_digest=_digest("provenance"), result_material_identity_digest=material.identity_digest, ) assert descriptor.matches_result_material(material) assert not descriptor.matches_result_material( MaterialIdentity.create( capability_id="skill:other-testing", kind="skill", content_sha256=material.content_sha256, content_bytes=material.content_bytes, ) ) def test_install_planning_bundle_requires_exact_v2_descriptor_and_full_material() -> None: material = MaterialIdentity.create( capability_id="skill:python-testing", kind="skill", content_sha256=_digest("installed-content"), content_bytes=128, ) descriptor = InstallPlanDescriptor.create( capability_id=material.capability_id, kind=material.kind, installer_id="ctx-builtin-installer-v1", plan_digest=_digest("install-plan-v2"), provenance_digest=_digest("install-catalog-v2"), result_material_identity_digest=material.identity_digest, ) bundle = InstallPlanningBundle(descriptor=descriptor, result_material=material) assert bundle.descriptor == descriptor assert bundle.result_material == material with pytest.raises(ValueError, match="schema v2"): InstallPlanningBundle(descriptor=_descriptor(), result_material=material) substituted = MaterialIdentity.create( capability_id=material.capability_id, kind=material.kind, content_sha256=_digest("substituted-content"), content_bytes=material.content_bytes, ) with pytest.raises(ValueError, match="result material"): InstallPlanningBundle(descriptor=descriptor, result_material=substituted) def test_descriptor_risk_declarations_are_strict_booleans() -> None: with pytest.raises(ValueError, match="permission_expansion"): InstallPlanDescriptor.create( capability_id="skill:python-testing", kind="skill", installer_id="ctx-installer-v1", plan_digest=_digest("plan"), provenance_digest=_digest("provenance"), permission_expansion=1, # type: ignore[arg-type] ) @pytest.mark.parametrize( ("capability_id", "kind"), [ ("harness:pytest", "harness"), ("agent:reviewer", "skill"), ("skill:reviewer", "agent"), ("skill:", "skill"), ("skill:reviewer:extra", "skill"), ], ) def test_descriptor_rejects_unsupported_or_inconsistent_kind( capability_id: str, kind: str, ) -> None: with pytest.raises(ValueError, match="kind"): _descriptor(capability_id=capability_id, kind=kind) @pytest.mark.parametrize( ("field_name", "unsafe_value"), [ ("capability_id", "skill:python testing"), ("capability_id", "skill:$(touch-pwned)"), ("installer_id", "/usr/local/bin/installer"), ("installer_id", "pip install package"), ("installer_id", "token=${SECRET}"), ], ) def test_descriptor_rejects_unsafe_tokens(field_name: str, unsafe_value: str) -> None: values: dict[str, str] = { "capability_id": "skill:python-testing", "kind": "skill", "installer_id": "ctx-installer-v1", "plan_digest": _digest("plan"), "provenance_digest": _digest("provenance"), } values[field_name] = unsafe_value with pytest.raises(ValueError, match=field_name): InstallPlanDescriptor.create( capability_id=values["capability_id"], kind=values["kind"], installer_id=values["installer_id"], plan_digest=values["plan_digest"], provenance_digest=values["provenance_digest"], ) def test_descriptor_rejects_non_user_scope_and_non_atomic_rollback() -> None: with pytest.raises(ValueError, match="target_scope"): InstallPlanDescriptor.create( capability_id="skill:python-testing", kind="skill", installer_id="ctx-installer-v1", plan_digest=_digest("plan"), provenance_digest=_digest("provenance"), target_scope="system", ) with pytest.raises(ValueError, match="rollback_strategy"): InstallPlanDescriptor.create( capability_id="skill:python-testing", kind="skill", installer_id="ctx-installer-v1", plan_digest=_digest("plan"), provenance_digest=_digest("provenance"), rollback_strategy="none", ) def test_safe_default_asks_for_each_kind_and_has_canonical_digest() -> None: policy = InstallConsentPolicy.safe_default() assert policy.mode_for("skill") == "ask-each-time" assert policy.mode_for("agent") == "ask-each-time" assert policy.mode_for("mcp-server") == "ask-each-time" assert InstallConsentPolicy.from_dict(policy.to_dict()) == policy tampered = policy.to_dict() tampered["skill_mode"] = "preapproved-auto" with pytest.raises(ValueError, match="policy_digest"): InstallConsentPolicy.from_dict(tampered) def test_policy_modes_are_independent_by_capability_kind() -> None: policy = InstallConsentPolicy( skill_mode="preapproved-auto", agent_mode="ask-each-time", mcp_server_mode="preapproved-auto", ) assert policy.mode_for("skill") == "preapproved-auto" assert policy.mode_for("agent") == "ask-each-time" assert policy.mode_for("mcp-server") == "preapproved-auto" def test_clean_exact_plan_uses_configured_decision_basis() -> None: descriptor = _descriptor() auto = InstallConsentPolicy(skill_mode="preapproved-auto") ask = InstallConsentPolicy() automatic = route_install_authorization(descriptor=descriptor, policy=auto) interactive = route_install_authorization(descriptor=descriptor, policy=ask) assert automatic.decision_basis == "preapproved-policy" assert automatic.policy_snapshot_digest == auto.policy_digest assert automatic.is_preapproved assert interactive.decision_basis == "interactive" assert interactive.policy_snapshot_digest == ask.policy_digest assert not interactive.is_preapproved def test_consent_dispatcher_auto_grants_only_a_current_preapproved_request() -> None: descriptor = _descriptor() policy = InstallConsentPolicy(skill_mode="preapproved-auto") request = _request(descriptor, policy) directive = route_install_consent_request( request, _selection(descriptor), descriptor, policy, ) assert not directive.requires_prompt assert directive.permission_expansion is False assert directive.credential_requirement is False assert directive.provenance_digest == descriptor.provenance_digest assert directive.automatic_grant_payload() == { "consent_id": "consent-1", "decision": "granted", "decision_basis": "preapproved-policy", "policy_snapshot_digest": policy.policy_digest, "requested_action_id": "install-action-1", "requested_action_kind": "InstallCapability", "requested_action_content_digest": _digest("install-action"), "requested_action_precondition_revision": 4, } changed = InstallConsentPolicy() with pytest.raises(InstallConsentRoutingError, match="current policy"): route_install_consent_request( request, _selection(descriptor), descriptor, changed, ) substituted = _descriptor(permission_expansion=True) assert substituted.plan_digest == descriptor.plan_digest assert substituted.descriptor_digest != descriptor.descriptor_digest with pytest.raises(InstallConsentRoutingError, match="current policy"): route_install_consent_request( request, _selection(descriptor), substituted, policy, ) def test_consent_dispatcher_preserves_independent_kind_policy_and_risk_ui() -> None: descriptor = _descriptor( capability_id="agent:python-reviewer", kind="agent", credential_requirement=True, ) policy = InstallConsentPolicy( skill_mode="preapproved-auto", agent_mode="ask-each-time", ) directive = route_install_consent_request( _request(descriptor, policy), _selection(descriptor), descriptor, policy, ) assert directive.requires_prompt assert directive.credential_requirement is True assert directive.reason_code == "credentials-require-consent" assert directive.automatic_grant_payload() is None assert directive.decision_payload("denied")["decision_basis"] == "interactive" @pytest.mark.parametrize(("capability_id", "kind"), INSTALLABLE_CAPABILITY_CASES) @pytest.mark.parametrize( ("mode", "expected_basis"), [ ("preapproved-auto", "preapproved-policy"), ("ask-each-time", "interactive"), ], ) def test_consent_dispatcher_routes_real_reducer_v3_requests_for_every_installable_kind( capability_id: str, kind: str, mode: str, expected_basis: str, ) -> None: policy = _policy_for_kind(kind, mode) request, selection, descriptor = _reducer_v3_consent_request(capability_id, policy) directive = route_install_consent_request(request, selection, descriptor, policy) authority = selection.authority assert isinstance(authority, InstallPlanningAuthority) assert directive.capability_id == capability_id assert directive.kind == kind assert directive.decision_basis == expected_basis assert directive.requires_prompt is (mode == "ask-each-time") assert directive.result_material_identity_digest == authority.result_material.identity_digest assert directive.decision_payload("granted") == { "consent_id": request.consent_id, "decision": "granted", "decision_basis": expected_basis, "policy_snapshot_digest": policy.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" ], } if mode == "preapproved-auto": assert directive.automatic_grant_payload() == directive.decision_payload("granted") else: assert directive.automatic_grant_payload() is None @pytest.mark.parametrize( ("permission_expansion", "credential_requirement", "reason_code"), [ (True, False, "permission-expansion-requires-consent"), (False, True, "credentials-require-consent"), ], ) def test_reducer_v3_risk_declarations_override_per_kind_preapproval( permission_expansion: bool, credential_requirement: bool, reason_code: str, ) -> None: policy = InstallConsentPolicy(mcp_server_mode="preapproved-auto") request, selection, descriptor = _reducer_v3_consent_request( "mcp-server:repository-tools", policy, permission_expansion=permission_expansion, credential_requirement=credential_requirement, ) directive = route_install_consent_request(request, selection, descriptor, policy) assert directive.requires_prompt assert directive.reason_code == reason_code assert directive.automatic_grant_payload() is None def test_reducer_v3_consent_dispatcher_rejects_cross_kind_selection_substitution() -> None: policy = InstallConsentPolicy.safe_default() request, _selection_value, _descriptor_value = _reducer_v3_consent_request( "skill:python-testing", policy, ) _other_request, other_selection, other_descriptor = _reducer_v3_consent_request( "agent:reviewer", policy, ) with pytest.raises(InstallConsentRoutingError, match="install identity"): route_install_consent_request(request, other_selection, other_descriptor, policy) def test_reducer_v3_consent_dispatcher_rejects_catalog_substitution() -> None: policy = InstallConsentPolicy.safe_default() request, selection, descriptor = _reducer_v3_consent_request( "skill:python-testing", policy, ) substituted = replace( selection, catalog_identity=CatalogCapabilityIdentity.create( capability_id=selection.presentation.capability_id, kind=selection.presentation.kind, catalog_namespace_digest=_digest("substituted-catalog-namespace"), ), ) with pytest.raises(InstallConsentRoutingError, match="install identity"): route_install_consent_request(request, substituted, descriptor, policy) @pytest.mark.parametrize("substitution", ["descriptor", "material"]) def test_reducer_v3_consent_dispatcher_rejects_descriptor_and_material_substitution( substitution: str, ) -> None: policy = InstallConsentPolicy.safe_default() request, selection, descriptor = _reducer_v3_consent_request( "skill:python-testing", policy, ) authority = selection.authority assert isinstance(authority, InstallPlanningAuthority) material = authority.result_material if substitution == "material": material = MaterialIdentity.create( capability_id=material.capability_id, kind=material.kind, content_sha256=_digest("substituted-result-material"), content_bytes=material.content_bytes, ) substituted_descriptor = InstallPlanDescriptor.create( capability_id=descriptor.capability_id, kind=descriptor.kind, installer_id=descriptor.installer_id, plan_digest=( _digest("substituted-install-plan") if substitution == "descriptor" else descriptor.plan_digest ), provenance_digest=descriptor.provenance_digest, permission_expansion=descriptor.permission_expansion, credential_requirement=descriptor.credential_requirement, result_material_identity_digest=material.identity_digest, ) substituted_selection = replace( selection, presentation=replace( selection.presentation, install_descriptor_digest=substituted_descriptor.descriptor_digest, install_plan_digest=substituted_descriptor.plan_digest, ), authority=InstallPlanningAuthority( descriptor=substituted_descriptor, result_material=material, ), ) with pytest.raises(InstallConsentRoutingError, match="install identity"): route_install_consent_request( request, substituted_selection, substituted_descriptor, policy, ) def test_reducer_v3_consent_dispatcher_rejects_current_policy_substitution() -> None: policy = InstallConsentPolicy(skill_mode="preapproved-auto") request, selection, descriptor = _reducer_v3_consent_request( "skill:python-testing", policy, ) with pytest.raises(InstallConsentRoutingError, match="current policy"): route_install_consent_request( request, selection, descriptor, InstallConsentPolicy.safe_default(), ) @pytest.mark.parametrize( ("permission_expansion", "credential_requirement", "reason_code"), [ (True, False, "permission-expansion-requires-consent"), (False, True, "credentials-require-consent"), ], ) def test_risky_descriptors_never_inherit_automatic_preapproval_before_prepare( permission_expansion: bool, credential_requirement: bool, reason_code: str, ) -> None: descriptor = _descriptor( permission_expansion=permission_expansion, credential_requirement=credential_requirement, ) policy = InstallConsentPolicy(skill_mode="preapproved-auto") decision = route_install_authorization(descriptor=descriptor, policy=policy) assert decision.decision_basis == "interactive" assert decision.authorization_eligible assert decision.reason_code == reason_code assert not decision.is_preapproved def test_prepared_plan_must_match_authenticated_descriptor_risk_declarations() -> None: descriptor = _descriptor(permission_expansion=True) policy = InstallConsentPolicy() prepared = _prepared(descriptor, policy) decision = route_install_authorization(policy, descriptor) assert prepared.matches_descriptor(descriptor) assert prepared.matches_authorization(descriptor, decision) assert not replace(prepared, permission_expansion=False).matches_descriptor(descriptor) assert not replace(prepared, credential_requirement=True).matches_descriptor(descriptor) assert not replace( prepared, consent_policy_digest=_digest("stale-policy"), ).matches_authorization(descriptor, decision) def test_uninstall_cannot_be_prepared_through_the_install_plan_contract() -> None: descriptor = _descriptor() policy = InstallConsentPolicy(skill_mode="preapproved-auto") with pytest.raises(ValueError, match="operation must be install"): _prepared(descriptor, policy, operation="uninstall") def test_prepared_plan_is_exactly_action_selection_catalog_and_plan_bound() -> None: descriptor = _descriptor() policy = InstallConsentPolicy(skill_mode="preapproved-auto") prepared = _prepared(descriptor, policy) assert prepared.action_id == "install-action-1" assert prepared.action_content_digest == _digest("action") assert prepared.selection_source_digest == _digest("selection") assert prepared.catalog_snapshot_digest == _digest("catalog") assert prepared.plan_digest == descriptor.plan_digest assert prepared.descriptor_digest == descriptor.descriptor_digest def test_durable_projections_cannot_accept_raw_commands_paths_or_secrets() -> None: descriptor = _descriptor() policy = InstallConsentPolicy() prepared = _prepared(descriptor, policy) forbidden_names = {"command", "shell", "path", "secret", "credential", "token_value"} assert forbidden_names.isdisjoint({item.name for item in fields(InstallPlanDescriptor)}) assert forbidden_names.isdisjoint({item.name for item in fields(PreparedInstallPlan)}) assert forbidden_names.isdisjoint(descriptor.to_dict()) assert forbidden_names.isdisjoint(prepared.to_dict()) assert "execution_token" not in prepared.to_dict() raw = descriptor.to_dict() raw["command"] = "pip install unsafe" with pytest.raises(ValueError, match="unknown fields"): InstallPlanDescriptor.from_dict(raw) @pytest.mark.parametrize("unsafe_token", ["/tmp/plan", "C:\\tmp\\plan", "$(env)", "has secret"]) def test_prepared_plan_rejects_path_shell_and_secret_shaped_execution_tokens( unsafe_token: str, ) -> None: descriptor = _descriptor() policy = InstallConsentPolicy() with pytest.raises(ValueError, match="execution_token"): _prepared(descriptor, policy, execution_token=unsafe_token)