| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| from collections.abc import Sequence |
| from dataclasses import dataclass, field |
| from typing import cast |
|
|
| import pytest |
| import ctx.runtime.planning_v3 as planning_v3_module |
|
|
| from ctx.engine.benefit import ( |
| BenefitCandidate, |
| BenefitSelectionResult, |
| EvidenceSummary, |
| NetBenefitPolicy, |
| ResourceCosts, |
| ) |
| from ctx.engine.content import MaterialDescriptor, MaterialIdentity |
| from ctx.engine.installation import InstallPlanDescriptor, InstallPlanningBundle |
| from ctx.engine.lineage import CatalogCapabilityIdentity |
| from ctx.engine.planner import ( |
| CandidateAuthorityUnavailable, |
| CandidateSourceUnavailable, |
| CapabilityCandidate, |
| PlannerValidationError, |
| WorkObservation, |
| ) |
| from ctx.engine.planning_v3 import ( |
| AuthenticatedNetBenefitPlanner, |
| BenefitAuditStore, |
| ) |
| from ctx.engine.protocol import ScopeRef |
| from ctx.engine.replay import PlanningContext, StructuredSurrogate |
| from ctx.engine.state import CapabilityState, EngineState, LeaseRef |
| from ctx.runtime.planning_v3 import ( |
| AuthenticatedReplayDecisionPlannerV3, |
| CatalogLoadPlanningBundle, |
| ) |
|
|
|
|
| def _digest(value: str) -> str: |
| return hashlib.sha256(value.encode()).hexdigest() |
|
|
|
|
| def _material(capability_id: str, salt: str | None = None) -> MaterialIdentity: |
| kind = capability_id.split(":", 1)[0] |
| return MaterialIdentity.create( |
| capability_id=capability_id, |
| kind=kind, |
| content_sha256=_digest(f"content:{salt or capability_id}"), |
| content_bytes=32, |
| ) |
|
|
|
|
| def _load_descriptor( |
| capability_id: str, |
| *, |
| schema_version: int = 2, |
| material_salt: str | None = None, |
| provenance_salt: str = "material-snapshot", |
| ) -> MaterialDescriptor: |
| kind = capability_id.split(":", 1)[0] |
| material = _material(capability_id, material_salt) |
| return MaterialDescriptor.create( |
| capability_id=capability_id, |
| kind=kind, |
| actionability="load", |
| content_sha256=material.content_sha256, |
| content_bytes=material.content_bytes, |
| estimated_tokens=8, |
| provenance_digest=_digest(provenance_salt), |
| material_identity_digest=(material.identity_digest if schema_version == 2 else None), |
| ) |
|
|
|
|
| def _install_bundle( |
| capability_id: str, |
| *, |
| provenance_salt: str = "install-snapshot", |
| result_salt: str = "installed", |
| ) -> InstallPlanningBundle: |
| kind = capability_id.split(":", 1)[0] |
| result = _material(capability_id, result_salt) |
| descriptor = InstallPlanDescriptor.create( |
| capability_id=capability_id, |
| kind=kind, |
| installer_id="ctx-installer-v1", |
| plan_digest=_digest(f"plan:{capability_id}"), |
| provenance_digest=_digest(provenance_salt), |
| result_material_identity_digest=result.identity_digest, |
| ) |
| return InstallPlanningBundle(descriptor=descriptor, result_material=result) |
|
|
|
|
| def _candidate( |
| capability_id: str, |
| actionability: str, |
| *, |
| source_salt: str | None = None, |
| ) -> CapabilityCandidate: |
| kind, name = capability_id.split(":", 1) |
| bundle = _install_bundle(capability_id) if actionability == "install" else None |
| return CapabilityCandidate( |
| capability_id=capability_id, |
| kind=kind, |
| name=name, |
| source_digest=_digest(f"source:{source_salt or capability_id}"), |
| normalized_score_ppm=900_000, |
| matching_signals=("python",), |
| reason_codes=("signal-match",), |
| actionability=actionability, |
| install_descriptor_digest=( |
| None |
| if actionability != "install" |
| else ( |
| bundle.descriptor.descriptor_digest |
| if bundle is not None |
| else _digest(f"descriptor:{capability_id}") |
| ) |
| ), |
| install_plan_digest=( |
| None |
| if actionability != "install" |
| else ( |
| bundle.descriptor.plan_digest |
| if bundle is not None |
| else _digest(f"plan:{capability_id}") |
| ) |
| ), |
| ) |
|
|
|
|
| def _benefit( |
| candidate: CapabilityCandidate, |
| *, |
| availability: str | None = None, |
| source_digest: str | None = None, |
| expected_task_benefit_ppm: int = 700_000, |
| ) -> BenefitCandidate: |
| tier = availability or ("advisory" if candidate.actionability == "manual" else "executable") |
| return BenefitCandidate( |
| capability_id=candidate.capability_id, |
| source_digest=source_digest or candidate.source_digest, |
| resource_profile_digest=_digest(f"profile:{candidate.capability_id}"), |
| availability=tier, |
| expected_task_benefit_ppm=expected_task_benefit_ppm, |
| relevance_ppm=1_000_000, |
| trust_ppm=1_000_000, |
| costs=ResourceCosts(), |
| evidence=EvidenceSummary( |
| capability_id=candidate.capability_id, |
| kind=candidate.kind, |
| source_digest=source_digest or candidate.source_digest, |
| evidence_window_digest=_digest(f"window:{candidate.capability_id}"), |
| opportunity_observable=False, |
| ), |
| source_trusted=True, |
| security_approved=True, |
| permissions_allowed=True, |
| credentials_available=True, |
| ) |
|
|
|
|
| @dataclass |
| class _AuditStore(BenefitAuditStore): |
| results: dict[str, BenefitSelectionResult] = field(default_factory=dict) |
|
|
| def store(self, result: BenefitSelectionResult) -> str: |
| self.results[result.result_digest] = result |
| return result.result_digest |
|
|
|
|
| @dataclass |
| class _Source: |
| values: Sequence[CapabilityCandidate] |
| catalog_snapshot_digest: str = field(default_factory=lambda: _digest("catalog-snapshot")) |
| observations: list[WorkObservation] = field(default_factory=list) |
|
|
| def retrieve(self, observation: WorkObservation) -> Sequence[CapabilityCandidate]: |
| self.observations.append(observation) |
| return self.values |
|
|
|
|
| @dataclass |
| class _Facts: |
| values: dict[str, BenefitCandidate | None] |
| benefit_facts_snapshot_digest: str = field(default_factory=lambda: _digest("benefit-facts")) |
| calls: list[str] = field(default_factory=list) |
|
|
| def benefit_candidate( |
| self, |
| presentation: CapabilityCandidate, |
| _observation: WorkObservation, |
| ) -> BenefitCandidate | None: |
| self.calls.append(presentation.capability_id) |
| return self.values.get(presentation.capability_id) |
|
|
|
|
| @dataclass |
| class _Materials: |
| values: dict[str, CatalogLoadPlanningBundle | MaterialDescriptor | None] |
| material_snapshot_digest: str = field(default_factory=lambda: _digest("material-snapshot")) |
| calls: list[str] = field(default_factory=list) |
|
|
| def load_bundle( |
| self, |
| presentation: CapabilityCandidate, |
| ) -> CatalogLoadPlanningBundle | None: |
| self.calls.append(presentation.capability_id) |
| return cast( |
| CatalogLoadPlanningBundle | None, |
| self.values.get(presentation.capability_id), |
| ) |
|
|
|
|
| @dataclass |
| class _Installs: |
| values: dict[str, InstallPlanningBundle | None] |
| installation_snapshot_digest: str = field(default_factory=lambda: _digest("install-snapshot")) |
| calls: list[str] = field(default_factory=list) |
|
|
| def describe_bundle(self, capability_id: str, _kind: str) -> InstallPlanningBundle | None: |
| self.calls.append(capability_id) |
| return self.values.get(capability_id) |
|
|
|
|
| def _observation( |
| *, |
| baseline: tuple[str, ...] = (), |
| active: tuple[str, ...] = (), |
| rejected: tuple[str, ...] = (), |
| requested_limit: int = 5, |
| ) -> StructuredSurrogate: |
| return StructuredSurrogate.create( |
| schema_id="ctx.observation.current-work", |
| schema_version=1, |
| value={ |
| "signals": ["python", "testing"], |
| "languages": ["python"], |
| "baseline_capability_ids": list(baseline), |
| "active_capability_ids": list(active), |
| "rejected_capability_ids": list(rejected), |
| "requested_limit": requested_limit, |
| }, |
| ) |
|
|
|
|
| def _catalog_load_bundle( |
| presentation: CapabilityCandidate, |
| *, |
| descriptor: MaterialDescriptor | None = None, |
| catalog_snapshot_digest: str | None = None, |
| catalog_namespace_digest: str | None = None, |
| ) -> CatalogLoadPlanningBundle: |
| value = descriptor or _load_descriptor(presentation.capability_id) |
| return CatalogLoadPlanningBundle( |
| presentation=presentation, |
| catalog_identity=CatalogCapabilityIdentity.create( |
| capability_id=presentation.capability_id, |
| kind=presentation.kind, |
| catalog_namespace_digest=(catalog_namespace_digest or _digest("catalog-namespace")), |
| ), |
| descriptor=value, |
| catalog_snapshot_digest=(catalog_snapshot_digest or _digest("catalog-snapshot")), |
| material_snapshot_digest=value.provenance_digest, |
| ) |
|
|
|
|
| def _adapter( |
| candidates: Sequence[CapabilityCandidate], |
| *, |
| facts: dict[str, BenefitCandidate | None] | None = None, |
| materials: dict[str, CatalogLoadPlanningBundle | MaterialDescriptor | None] | None = None, |
| installs: dict[str, InstallPlanningBundle | None] | None = None, |
| ) -> tuple[ |
| AuthenticatedReplayDecisionPlannerV3, |
| _Source, |
| _Facts, |
| _Materials, |
| _Installs, |
| ]: |
| source = _Source(candidates) |
| facts_port = _Facts( |
| facts |
| if facts is not None |
| else {candidate.capability_id: _benefit(candidate) for candidate in candidates} |
| ) |
| material_port = _Materials( |
| materials |
| if materials is not None |
| else { |
| candidate.capability_id: _catalog_load_bundle(candidate) |
| for candidate in candidates |
| if candidate.actionability == "load" |
| } |
| ) |
| install_port = _Installs( |
| installs |
| if installs is not None |
| else { |
| candidate.capability_id: _install_bundle(candidate.capability_id) |
| for candidate in candidates |
| if candidate.actionability == "install" |
| } |
| ) |
| adapter = AuthenticatedReplayDecisionPlannerV3( |
| planner=AuthenticatedNetBenefitPlanner( |
| policy=NetBenefitPolicy( |
| calibration_digest=_digest("calibration"), |
| minimum_relevance_ppm=1, |
| ), |
| audit_store=_AuditStore(), |
| ), |
| source=source, |
| benefit_facts_port=facts_port, |
| material_port=material_port, |
| install_bundle_port=install_port, |
| planner_version="planner-v3", |
| catalog_namespace_digest=_digest("catalog-namespace"), |
| ) |
| return adapter, source, facts_port, material_port, install_port |
|
|
|
|
| def _context(adapter: AuthenticatedReplayDecisionPlannerV3) -> PlanningContext: |
| return PlanningContext( |
| planner_version="planner-v3", |
| catalog_snapshot_digest=adapter.catalog_snapshot_digest, |
| ) |
|
|
|
|
| def _active_state(candidate: CapabilityCandidate) -> EngineState: |
| lease = LeaseRef( |
| lease_id="lease-active", |
| owner_id="owner-active", |
| exposure_id="exposure-1", |
| ) |
| return EngineState( |
| revision=1, |
| 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", |
| ), |
| host_level="activating", |
| host_descriptor_digest=_digest("host"), |
| capabilities=( |
| CapabilityState( |
| capability_id=candidate.capability_id, |
| source_digest=candidate.source_digest, |
| plan_id="plan-active", |
| catalog_snapshot_id=_digest("catalog-snapshot"), |
| kind=candidate.kind, |
| actionability=candidate.actionability, |
| leases=(lease,), |
| activation="active", |
| activation_lease_id=lease.lease_id, |
| ), |
| ), |
| _contract_version=2, |
| ) |
|
|
|
|
| def test_emits_only_schema_v3_for_mixed_load_install_and_manual_authorities() -> None: |
| candidates = ( |
| _candidate("agent:advisor", "manual"), |
| _candidate("skill:remote", "install"), |
| _candidate("skill:local", "load"), |
| ) |
| adapter, _source, _facts, _materials, _installs = _adapter(candidates) |
|
|
| decision = adapter(_observation(), None, _context(adapter)) |
|
|
| assert (decision.schema_id, decision.schema_version) == ( |
| "ctx.decision.capability-plan", |
| 3, |
| ) |
| rows = decision.to_dict()["value"]["capabilities"] |
| assert [row["capability_id"] for row in rows] == [ |
| "skill:local", |
| "skill:remote", |
| "agent:advisor", |
| ] |
| assert [row["authority"]["type"] for row in rows] == ["load", "install", "manual"] |
| assert rows[0]["authority"]["material"]["origin"] == "catalog" |
| assert rows[1]["authority"]["descriptor"]["schema"] == "ctx.install-plan-descriptor-v2" |
| assert rows[2]["authority"] == {"type": "manual"} |
|
|
|
|
| @pytest.mark.parametrize( |
| ("candidates", "requested_limit", "code"), |
| [ |
| ((), 5, "no-feasible-capability"), |
| ((_candidate("skill:local", "load"),), 0, "limit-zero"), |
| ], |
| ) |
| def test_preserves_zero_selection_abstention( |
| candidates: Sequence[CapabilityCandidate], |
| requested_limit: int, |
| code: str, |
| ) -> None: |
| adapter, _source, _facts, _materials, _installs = _adapter(candidates) |
|
|
| value = adapter( |
| _observation(requested_limit=requested_limit), |
| None, |
| _context(adapter), |
| ).to_dict()["value"] |
|
|
| assert value["status"] == "abstained" |
| assert value["abstention_code"] == code |
| assert value["capabilities"] == [] |
| assert value["benefit_audit"] is not None |
|
|
|
|
| def test_declared_candidate_source_unavailability_emits_schema_v3_degradation() -> None: |
| class _UnavailableSource(_Source): |
| def retrieve(self, observation: WorkObservation) -> Sequence[CapabilityCandidate]: |
| self.observations.append(observation) |
| raise CandidateSourceUnavailable("private graph failure") |
|
|
| adapter, source, facts, materials, installs = _adapter(()) |
| unavailable = _UnavailableSource((), catalog_snapshot_digest=source.catalog_snapshot_digest) |
| adapter = AuthenticatedReplayDecisionPlannerV3( |
| planner=adapter.planner, |
| source=unavailable, |
| benefit_facts_port=facts, |
| material_port=materials, |
| install_bundle_port=installs, |
| planner_version="planner-v3", |
| catalog_namespace_digest=_digest("catalog-namespace"), |
| ) |
|
|
| value = adapter(_observation(), None, _context(adapter)).to_dict()["value"] |
|
|
| assert value == { |
| "status": "degraded", |
| "abstention_code": "catalog-unavailable", |
| "benefit_audit": None, |
| "capabilities": [], |
| } |
| assert "private graph failure" not in str(value) |
|
|
|
|
| @pytest.mark.parametrize("mode", ["missing", "mismatched-id", "mismatched-source"]) |
| def test_rejects_missing_or_mismatched_authenticated_benefit_facts(mode: str) -> None: |
| candidate = _candidate("skill:local", "load") |
| facts: dict[str, BenefitCandidate | None] |
| if mode == "missing": |
| facts = {candidate.capability_id: None} |
| elif mode == "mismatched-id": |
| other = _candidate("skill:other", "load") |
| facts = {candidate.capability_id: _benefit(other)} |
| else: |
| facts = { |
| candidate.capability_id: _benefit( |
| candidate, |
| source_digest=_digest("substituted-source"), |
| ) |
| } |
| adapter, _source, _facts, _materials, _installs = _adapter((candidate,), facts=facts) |
|
|
| with pytest.raises(PlannerValidationError, match="benefit"): |
| adapter(_observation(), None, _context(adapter)) |
|
|
|
|
| def test_isolates_v1_load_descriptor_without_downgrading_to_manual() -> None: |
| candidate = _candidate("skill:local", "load") |
| adapter, _source, _facts, _materials, _installs = _adapter( |
| (candidate,), |
| materials={ |
| candidate.capability_id: _load_descriptor(candidate.capability_id, schema_version=1) |
| }, |
| ) |
|
|
| value = adapter(_observation(), None, _context(adapter)).to_dict()["value"] |
|
|
| assert value["status"] == "abstained" |
| assert value["capabilities"] == [] |
|
|
|
|
| def test_rejects_load_descriptor_from_a_different_material_snapshot() -> None: |
| candidate = _candidate("skill:local", "load") |
| descriptor = _load_descriptor(candidate.capability_id) |
| materials = _Materials( |
| {candidate.capability_id: _catalog_load_bundle(candidate, descriptor=descriptor)}, |
| material_snapshot_digest=_digest("different-material-snapshot"), |
| ) |
| adapter, source, facts, _default_materials, installs = _adapter((candidate,)) |
| adapter = AuthenticatedReplayDecisionPlannerV3( |
| planner=adapter.planner, |
| source=source, |
| benefit_facts_port=facts, |
| material_port=materials, |
| install_bundle_port=installs, |
| planner_version="planner-v3", |
| catalog_namespace_digest=_digest("catalog-namespace"), |
| ) |
|
|
| value = adapter(_observation(), None, _context(adapter)).to_dict()["value"] |
|
|
| assert value["status"] == "abstained" |
| assert value["capabilities"] == [] |
|
|
|
|
| @pytest.mark.parametrize("mode", ["missing", "substituted"]) |
| def test_isolates_missing_or_substituted_install_bundle_instead_of_manual( |
| mode: str, |
| ) -> None: |
| candidate = _candidate("skill:remote", "install") |
| bundle = None if mode == "missing" else _install_bundle("skill:other") |
| adapter, _source, _facts, _materials, _installs = _adapter( |
| (candidate,), |
| installs={candidate.capability_id: bundle}, |
| ) |
|
|
| value = adapter(_observation(), None, _context(adapter)).to_dict()["value"] |
|
|
| assert value["status"] == "abstained" |
| assert value["capabilities"] == [] |
|
|
|
|
| def test_rejects_install_bundle_from_a_different_installation_snapshot() -> None: |
| candidate = _candidate("skill:remote", "install") |
| adapter, _source, _facts, _materials, _installs = _adapter( |
| (candidate,), |
| installs={ |
| candidate.capability_id: _install_bundle( |
| candidate.capability_id, |
| provenance_salt="different-install-snapshot", |
| ) |
| }, |
| ) |
|
|
| value = adapter(_observation(), None, _context(adapter)).to_dict()["value"] |
|
|
| assert value["status"] == "abstained" |
| assert value["capabilities"] == [] |
|
|
|
|
| def test_rejects_planner_catalog_and_injected_port_snapshot_drift() -> None: |
| candidate = _candidate("skill:local", "load") |
| adapter, source, facts, materials, installs = _adapter((candidate,)) |
|
|
| with pytest.raises(PlannerValidationError, match="planner version"): |
| adapter( |
| _observation(), |
| None, |
| PlanningContext( |
| planner_version="different-planner", |
| catalog_snapshot_digest=source.catalog_snapshot_digest, |
| ), |
| ) |
| with pytest.raises(PlannerValidationError, match="catalog snapshot"): |
| adapter( |
| _observation(), |
| None, |
| PlanningContext( |
| planner_version="planner-v3", |
| catalog_snapshot_digest=_digest("different-catalog"), |
| ), |
| ) |
|
|
| for port, attribute, message in ( |
| (source, "catalog_snapshot_digest", "catalog snapshot"), |
| (facts, "benefit_facts_snapshot_digest", "benefit facts snapshot"), |
| (materials, "material_snapshot_digest", "material snapshot"), |
| (installs, "installation_snapshot_digest", "installation snapshot"), |
| ): |
| setattr(port, attribute, _digest(f"changed:{attribute}")) |
| with pytest.raises(PlannerValidationError, match=message): |
| adapter(_observation(), None, _context(adapter)) |
| setattr(port, attribute, getattr(adapter, f"_{attribute}")) |
|
|
|
|
| def test_excludes_baseline_and_rejected_before_authenticated_fact_lookup() -> None: |
| baseline = _candidate("skill:baseline", "load") |
| rejected = _candidate("agent:rejected", "manual") |
| selected = _candidate("skill:selected", "load") |
| adapter, _source, facts, materials, _installs = _adapter((baseline, rejected, selected)) |
|
|
| decision = adapter( |
| _observation( |
| baseline=(baseline.capability_id,), |
| rejected=(rejected.capability_id,), |
| ), |
| None, |
| _context(adapter), |
| ) |
|
|
| rows = decision.to_dict()["value"]["capabilities"] |
| assert [row["capability_id"] for row in rows] == [selected.capability_id] |
| assert facts.calls == [selected.capability_id, selected.capability_id] |
| assert materials.calls == [selected.capability_id, selected.capability_id] |
|
|
|
|
| def test_authoritative_state_active_ids_replace_observed_active_ids_without_exclusion() -> None: |
| active = _candidate("skill:active", "load") |
| adapter, source, _facts, _materials, _installs = _adapter((active,)) |
|
|
| decision = adapter( |
| _observation(active=("skill:forged",)), |
| _active_state(active), |
| _context(adapter), |
| ) |
|
|
| assert source.observations[0].active_capability_ids == (active.capability_id,) |
| assert decision.to_dict()["value"]["capabilities"][0]["capability_id"] == active.capability_id |
|
|
|
|
| def test_excludes_ambiguous_duplicate_identity_but_deduplicates_exact_rows() -> None: |
| exact = _candidate("skill:exact", "load") |
| ambiguous_a = _candidate("skill:ambiguous", "load", source_salt="a") |
| ambiguous_b = _candidate("skill:ambiguous", "load", source_salt="b") |
| adapter, _source, facts, _materials, _installs = _adapter( |
| (ambiguous_a, exact, ambiguous_b, exact), |
| facts={exact.capability_id: _benefit(exact)}, |
| ) |
|
|
| decision = adapter(_observation(), None, _context(adapter)) |
|
|
| assert [row["capability_id"] for row in decision.to_dict()["value"]["capabilities"]] == [ |
| exact.capability_id |
| ] |
| assert facts.calls == [exact.capability_id, exact.capability_id] |
|
|
|
|
| @pytest.mark.parametrize("requested_limit", [-1, 6, True]) |
| def test_rejects_invalid_requested_limit_before_retrieval(requested_limit: int) -> None: |
| candidate = _candidate("skill:local", "load") |
| adapter, source, _facts, _materials, _installs = _adapter((candidate,)) |
|
|
| with pytest.raises(PlannerValidationError, match="requested_limit"): |
| adapter( |
| _observation(requested_limit=requested_limit), |
| None, |
| _context(adapter), |
| ) |
| assert source.observations == [] |
|
|
|
|
| def test_rejects_oversized_candidate_pool() -> None: |
| repeated = tuple(_candidate(f"skill:item-{index}", "manual") for index in range(513)) |
| adapter, _source, _facts, _materials, _installs = _adapter(repeated) |
|
|
| with pytest.raises(PlannerValidationError, match="candidate pool"): |
| adapter(_observation(), None, _context(adapter)) |
|
|
|
|
| def test_rejects_non_current_work_and_unknown_observation_fields() -> None: |
| adapter, source, _facts, _materials, _installs = _adapter(()) |
| wrong = StructuredSurrogate.create( |
| schema_id="ctx.observation.other", |
| schema_version=1, |
| value={}, |
| ) |
| unknown = StructuredSurrogate.create( |
| schema_id="ctx.observation.current-work", |
| schema_version=1, |
| value={**_observation().to_dict()["value"], "raw_prompt": "raw-prompt"}, |
| ) |
|
|
| with pytest.raises(PlannerValidationError, match="current-work"): |
| adapter(wrong, None, _context(adapter)) |
| with pytest.raises(PlannerValidationError, match="fields"): |
| adapter(unknown, None, _context(adapter)) |
| assert source.observations == [] |
|
|
|
|
| def test_decision_surrogate_never_contains_raw_port_data() -> None: |
| candidate = _candidate("skill:local", "load") |
| adapter, _source, _facts, _materials, _installs = _adapter((candidate,)) |
|
|
| decision = adapter(_observation(), None, _context(adapter)) |
|
|
| encoded = decision.to_json() |
| assert "raw_prompt" not in encoded |
| assert "filesystem_path" not in encoded |
| assert "material body" not in encoded |
|
|
|
|
| def test_planning_context_digest_binds_the_complete_planning_environment() -> None: |
| candidate = _candidate("skill:local", "load") |
| adapter, source, facts, materials, installs = _adapter((candidate,)) |
| expected = hashlib.sha256( |
| json.dumps( |
| { |
| "benefit_facts_snapshot_digest": facts.benefit_facts_snapshot_digest, |
| "calibration_digest": adapter.planner.policy.calibration_digest, |
| "catalog_namespace_digest": _digest("catalog-namespace"), |
| "catalog_retrieval_snapshot_digest": source.catalog_snapshot_digest, |
| "installation_snapshot_digest": installs.installation_snapshot_digest, |
| "material_snapshot_digest": materials.material_snapshot_digest, |
| "planner_version": "planner-v3", |
| "policy_digest": adapter.planner.policy.policy_digest, |
| "schema": "ctx.planning-environment-v1", |
| }, |
| ensure_ascii=True, |
| allow_nan=False, |
| separators=(",", ":"), |
| sort_keys=True, |
| ).encode() |
| ).hexdigest() |
|
|
| assert adapter.catalog_snapshot_digest == expected |
| assert adapter.catalog_retrieval_snapshot_digest == source.catalog_snapshot_digest |
| assert adapter.catalog_snapshot_digest != source.catalog_snapshot_digest |
| with pytest.raises(PlannerValidationError, match="planning environment"): |
| adapter( |
| _observation(), |
| None, |
| PlanningContext( |
| planner_version="planner-v3", |
| catalog_snapshot_digest=source.catalog_snapshot_digest, |
| ), |
| ) |
|
|
|
|
| def test_typed_install_bundles_are_supported_uniformly_across_installable_kinds() -> None: |
| candidates = ( |
| _candidate("skill:remote", "install"), |
| _candidate("agent:remote", "install"), |
| _candidate("mcp-server:remote", "install"), |
| ) |
| adapter, _source, _facts, _materials, _installs = _adapter(candidates) |
|
|
| rows = adapter(_observation(), None, _context(adapter)).to_dict()["value"]["capabilities"] |
|
|
| assert [row["capability_id"] for row in rows] == [ |
| "agent:remote", |
| "mcp-server:remote", |
| "skill:remote", |
| ] |
| assert {row["authority"]["type"] for row in rows} == {"install"} |
|
|
|
|
| def test_invalid_install_authority_is_local_to_one_candidate() -> None: |
| invalid = _candidate("agent:remote", "install") |
| valid = _candidate("skill:local", "load") |
| adapter, _source, _facts, _materials, installs = _adapter( |
| (invalid, valid), |
| installs={invalid.capability_id: None}, |
| ) |
|
|
| rows = adapter(_observation(), None, _context(adapter)).to_dict()["value"]["capabilities"] |
|
|
| assert [row["capability_id"] for row in rows] == [valid.capability_id] |
| assert installs.calls == [invalid.capability_id, invalid.capability_id] |
|
|
|
|
| def test_malformed_install_bundle_is_local_to_one_candidate() -> None: |
| invalid = _candidate("agent:remote", "install") |
| valid = _candidate("skill:local", "load") |
| adapter, _source, _facts, _materials, installs = _adapter( |
| (invalid, valid), |
| installs={invalid.capability_id: cast(InstallPlanningBundle, object())}, |
| ) |
|
|
| rows = adapter(_observation(), None, _context(adapter)).to_dict()["value"]["capabilities"] |
|
|
| assert [row["capability_id"] for row in rows] == [valid.capability_id] |
| assert rows[0]["authority"]["type"] == "load" |
| assert installs.calls == [invalid.capability_id, invalid.capability_id] |
|
|
|
|
| def test_direct_load_authority_valid_to_unavailable_is_global_across_observations() -> None: |
| candidate = _candidate("skill:local", "load") |
| adapter, source, facts, materials, installs = _adapter((candidate,)) |
|
|
| class _UnavailableMaterials(_Materials): |
| unavailable = False |
|
|
| def load_bundle( |
| self, |
| presentation: CapabilityCandidate, |
| ) -> CatalogLoadPlanningBundle | None: |
| if self.unavailable: |
| raise CandidateAuthorityUnavailable("injected candidate-local failure") |
| return super().load_bundle(presentation) |
|
|
| changing = _UnavailableMaterials( |
| dict(materials.values), |
| material_snapshot_digest=materials.material_snapshot_digest, |
| ) |
| adapter = AuthenticatedReplayDecisionPlannerV3( |
| planner=adapter.planner, |
| source=source, |
| benefit_facts_port=facts, |
| material_port=changing, |
| install_bundle_port=installs, |
| planner_version="planner-v3", |
| catalog_namespace_digest=_digest("catalog-namespace"), |
| ) |
| adapter(_observation(), None, _context(adapter)) |
| changing.unavailable = True |
|
|
| with pytest.raises(PlannerValidationError, match="load authority output drifted"): |
| adapter( |
| _observation(active=("skill:unrelated",)), |
| None, |
| _context(adapter), |
| ) |
|
|
|
|
| def test_direct_install_authority_valid_to_unavailable_is_global_across_observations() -> None: |
| candidate = _candidate("skill:remote", "install") |
| adapter, source, facts, materials, installs = _adapter((candidate,)) |
|
|
| class _UnavailableInstalls(_Installs): |
| unavailable = False |
|
|
| def describe_bundle( |
| self, |
| capability_id: str, |
| kind: str, |
| ) -> InstallPlanningBundle | None: |
| if self.unavailable: |
| raise CandidateAuthorityUnavailable("injected candidate-local failure") |
| return super().describe_bundle(capability_id, kind) |
|
|
| changing = _UnavailableInstalls( |
| dict(installs.values), |
| installation_snapshot_digest=installs.installation_snapshot_digest, |
| ) |
| adapter = AuthenticatedReplayDecisionPlannerV3( |
| planner=adapter.planner, |
| source=source, |
| benefit_facts_port=facts, |
| material_port=materials, |
| install_bundle_port=changing, |
| planner_version="planner-v3", |
| catalog_namespace_digest=_digest("catalog-namespace"), |
| ) |
| adapter(_observation(), None, _context(adapter)) |
| changing.unavailable = True |
|
|
| with pytest.raises(PlannerValidationError, match="install authority output drifted"): |
| adapter( |
| _observation(active=("skill:unrelated",)), |
| None, |
| _context(adapter), |
| ) |
|
|
|
|
| def test_load_authority_rejects_a_different_retrieval_presentation() -> None: |
| candidate = _candidate("skill:local", "load") |
| substituted = _candidate("skill:local", "load", source_salt="substituted") |
| adapter, _source, _facts, materials, _installs = _adapter( |
| (candidate,), |
| materials={candidate.capability_id: _catalog_load_bundle(substituted)}, |
| ) |
|
|
| value = adapter(_observation(), None, _context(adapter)).to_dict()["value"] |
|
|
| assert value["status"] == "abstained" |
| assert value["capabilities"] == [] |
| assert materials.calls == [candidate.capability_id, candidate.capability_id] |
|
|
|
|
| def test_typed_load_bundle_cannot_mix_cross_snapshot_material() -> None: |
| invalid = _candidate("skill:cross-snapshot", "load") |
| valid = _candidate("skill:valid-load", "load") |
| cross_snapshot = _load_descriptor( |
| invalid.capability_id, |
| provenance_salt="other-material-snapshot", |
| ) |
| adapter, _source, _facts, _materials, _installs = _adapter( |
| (invalid, valid), |
| materials={ |
| invalid.capability_id: _catalog_load_bundle( |
| invalid, |
| descriptor=cross_snapshot, |
| ), |
| valid.capability_id: _catalog_load_bundle(valid), |
| }, |
| ) |
|
|
| rows = adapter(_observation(), None, _context(adapter)).to_dict()["value"]["capabilities"] |
|
|
| assert [row["capability_id"] for row in rows] == [valid.capability_id] |
| assert rows[0]["authority"]["type"] == "load" |
|
|
|
|
| def test_end_validation_catches_same_digest_output_mutation_on_first_call() -> None: |
| candidate = _candidate("skill:local", "load") |
| adapter, source, facts, materials, installs = _adapter((candidate,)) |
| first = materials.values[candidate.capability_id] |
| replacement = _catalog_load_bundle( |
| candidate, |
| descriptor=_load_descriptor(candidate.capability_id, material_salt="replacement"), |
| ) |
|
|
| class _MutatingMaterials(_Materials): |
| def load_bundle( |
| self, |
| presentation: CapabilityCandidate, |
| ) -> CatalogLoadPlanningBundle | None: |
| value = super().load_bundle(presentation) |
| if len(self.calls) == 1: |
| self.values[presentation.capability_id] = replacement |
| return value |
|
|
| mutating = _MutatingMaterials( |
| {candidate.capability_id: cast(CatalogLoadPlanningBundle, first)}, |
| material_snapshot_digest=materials.material_snapshot_digest, |
| ) |
| adapter = AuthenticatedReplayDecisionPlannerV3( |
| planner=adapter.planner, |
| source=source, |
| benefit_facts_port=facts, |
| material_port=mutating, |
| install_bundle_port=installs, |
| planner_version="planner-v3", |
| catalog_namespace_digest=_digest("catalog-namespace"), |
| ) |
|
|
| with pytest.raises(PlannerValidationError, match="output drifted"): |
| adapter(_observation(), None, _context(adapter)) |
|
|
|
|
| def test_port_cannot_hide_concurrent_digest_drift_during_a_read() -> None: |
| candidate = _candidate("skill:local", "load") |
| adapter, source, facts, materials, installs = _adapter((candidate,)) |
|
|
| class _DriftingMaterials(_Materials): |
| def load_bundle( |
| self, |
| presentation: CapabilityCandidate, |
| ) -> CatalogLoadPlanningBundle | None: |
| value = super().load_bundle(presentation) |
| self.material_snapshot_digest = _digest("concurrent-drift") |
| return value |
|
|
| drifting = _DriftingMaterials( |
| dict(materials.values), |
| material_snapshot_digest=materials.material_snapshot_digest, |
| ) |
| adapter = AuthenticatedReplayDecisionPlannerV3( |
| planner=adapter.planner, |
| source=source, |
| benefit_facts_port=facts, |
| material_port=drifting, |
| install_bundle_port=installs, |
| planner_version="planner-v3", |
| catalog_namespace_digest=_digest("catalog-namespace"), |
| ) |
|
|
| with pytest.raises(PlannerValidationError, match="material snapshot drifted"): |
| adapter(_observation(), None, _context(adapter)) |
|
|
|
|
| def test_snapshot_output_memory_is_bounded_and_never_evicts_drift_evidence( |
| monkeypatch: pytest.MonkeyPatch, |
| ) -> None: |
| monkeypatch.setattr(planning_v3_module, "_MAX_PINNED_SNAPSHOT_OUTPUTS", 1) |
| adapter, _source, _facts, _materials, _installs = _adapter(()) |
|
|
| adapter(_observation(requested_limit=5), None, _context(adapter)) |
| with pytest.raises(PlannerValidationError, match="bound is exhausted"): |
| adapter(_observation(requested_limit=4), None, _context(adapter)) |
|
|
