from __future__ import annotations import hashlib import inspect import os from collections.abc import Iterator from contextlib import contextmanager from dataclasses import dataclass, field from datetime import UTC, datetime from pathlib import Path from typing import cast import networkx as nx import pytest import ctx.runtime.composition as composition_module from ctx.core.graph.graph_store import build_graph_store from ctx.core.install_policy_store import persist_install_policy from ctx.core.resolve.engine_candidates import IndexedGraphCandidateSource from ctx.core.resolve.engine_content import AuthenticatedCatalogContentSource from ctx.engine.benefit import ( BenefitCandidate, EvidenceSummary, NetBenefitPolicy, ResourceCosts, ) from ctx.engine.benefit_audit_store import SQLiteBenefitAuditStore from ctx.engine.content import MaterialDescriptor, MaterialIdentity from ctx.engine.engine import CtxEngineError from ctx.engine.installation import ( InstallConsentPolicy, InstallPlanDescriptor, InstallPlanningBundle, InteractiveInstallDecisionReservation, PreparedInstallPlan, ) from ctx.engine.planner import ( CandidateAuthorityUnavailable, CandidateSourceUnavailable, CapabilityCandidate, PlannerValidationError, WorkObservation, ) from ctx.engine.protocol import EngineEvent, ScopeRef from ctx.engine.replay import ( ObservationReference, ReplayValidationError, StructuredSurrogate, ) from ctx.engine.state import CapabilityStateV3, CommittedPlanV3, EngineState from ctx.runtime import ( AgentFileRuntimeConfig, EngineComposition, SkillCasRuntimeConfig, open_engine_composition, ) from ctx.runtime.composition import open_managed_engine_composition from ctx.runtime.install_execution import InstallDriverRequest from ctx.runtime.managed_artifact_registry import ( ManagedArtifactHandle, ManagedArtifactRegistry, ManagedArtifactRegistryError, open_managed_artifact_registry, ) from ctx.runtime.managed_query import PreparedManagedQuery NOW = "2026-08-01T12:00:00Z" CATALOG_NAMESPACE_DIGEST = hashlib.sha256(b"catalog-namespace-v1").hexdigest() _REQUIRES_POSIX_MANAGED_REGISTRY = pytest.mark.skipif( os.name == "nt", reason="managed artifact registry requires POSIX filesystem semantics", ) def _trusted_now() -> datetime: return datetime(2026, 8, 1, 12, 30, tzinfo=UTC) def _digest(value: str) -> str: return hashlib.sha256(value.encode("utf-8")).hexdigest() def _artifact_digest(path: Path) -> str: return hashlib.sha256(path.read_bytes()).hexdigest() def _policy() -> NetBenefitPolicy: return NetBenefitPolicy( calibration_digest=_digest("calibration-v1"), minimum_relevance_ppm=1, ) @dataclass class _AuthenticatedFacts: benefit_facts_snapshot_digest: str = field( default_factory=lambda: _digest("authenticated-benefit-facts-v1") ) expected_task_benefit_ppm: int = 700_000 missing: bool = False calls: list[str] = field(default_factory=list) def benefit_candidate( self, presentation: CapabilityCandidate, _observation: WorkObservation, ) -> BenefitCandidate | None: self.calls.append(presentation.capability_id) if self.missing: return None return BenefitCandidate( capability_id=presentation.capability_id, source_digest=presentation.source_digest, resource_profile_digest=_digest(f"profile:{presentation.capability_id}"), availability=("advisory" if presentation.actionability == "manual" else "executable"), expected_task_benefit_ppm=self.expected_task_benefit_ppm, relevance_ppm=1_000_000, trust_ppm=1_000_000, costs=ResourceCosts(), evidence=EvidenceSummary( capability_id=presentation.capability_id, kind=presentation.kind, source_digest=presentation.source_digest, evidence_window_digest=_digest(f"window:{presentation.capability_id}"), opportunity_observable=False, ), source_trusted=True, security_approved=True, permissions_allowed=True, credentials_available=True, ) def _graph_artifact(tmp_path: Path) -> Path: graph = nx.Graph() graph.add_node( "skill:python-tdd", label="python-tdd", type="skill", tags=["python", "testing", "unit"], ) path = tmp_path / "graph-store.sqlite3" build_graph_store(path, graph) path.chmod(0o444) return path def _two_skill_graph_artifact(tmp_path: Path) -> Path: graph = nx.Graph() for name in ("python-bad", "python-good"): graph.add_node( f"skill:{name}", label=name, type="skill", tags=["python", "testing", "unit"], ) path = tmp_path / "two-skill-graph-store.sqlite3" build_graph_store(path, graph) path.chmod(0o444) return path def _agent_graph_artifact(tmp_path: Path) -> Path: graph = nx.Graph() graph.add_node( "agent:reviewer", label="reviewer", type="agent", tags=["python", "testing", "unit"], ) path = tmp_path / "agent-graph-store.sqlite3" build_graph_store(path, graph) path.chmod(0o444) return path def _cross_type_graph_artifact(tmp_path: Path) -> Path: graph = nx.Graph() for capability_id, kind in ( ("skill:python-tdd", "skill"), ("agent:reviewer", "agent"), ("mcp-server:docs", "mcp-server"), ("harness:python-runner", "harness"), ): graph.add_node( capability_id, label=capability_id.split(":", 1)[1], type=kind, tags=["python", "testing", "unit"], ) path = tmp_path / "cross-type-graph-store.sqlite3" build_graph_store(path, graph) path.chmod(0o444) return path def _normalizer( _reference: ObservationReference, _state: EngineState | None, ) -> StructuredSurrogate: return StructuredSurrogate.create( schema_id="ctx.observation.current-work", schema_version=1, value={ "signals": ["python", "testing", "unit"], "languages": ["python"], "baseline_capability_ids": [], "active_capability_ids": [], "rejected_capability_ids": [], "requested_limit": 5, }, ) def _scope() -> ScopeRef: return ScopeRef( tenant_id="tenant-1", workspace_id="workspace-1", repository_id="repository-1", session_id="session-1", exposure_id="exposure-1", host_context_id="host-neutral", ) def _event( composition: EngineComposition, kind: str, revision: int, event_id: str, *, payload: dict[str, object] | None = None, ) -> EngineEvent: return EngineEvent( event_id=event_id, kind=kind, scope=_scope(), expected_revision=revision, occurred_at=NOW, payload=payload or {}, correlation_id="plan-1", causation_id="cause-1", engine_version="ctx-engine-v1", planner_version=composition.planner_version, policy_version="policy-v1", host_descriptor_digest=_digest("host-neutral-managing-v1"), catalog_snapshot_digest=composition.catalog_snapshot_digest, semantic_model_digest=_digest("semantic-disabled"), semantic_index_digest=_digest("semantic-index-disabled"), work_signature=_digest("python-testing-unit"), random_seed=0, ) def _plan(composition: EngineComposition) -> tuple[dict[str, object], ...]: composition.process( _event( composition, "SessionStarted", 0, "event-start", payload={"host_level": "managing"}, ) ) transition = composition.process( _event( composition, "IntentObserved", 1, "event-intent", payload={ "observation_ref": { "provider_id": "test-buffer", "opaque_id": "observation-1", "content_digest": _digest("python-testing-unit"), } }, ) ) assert [action.kind for action in transition.actions] == ["PresentBundle"] return transition.actions[0].payload["capabilities"] # type: ignore[return-value] def _plan_with_observation_reference( composition: EngineComposition, reference: ObservationReference, ) -> tuple[dict[str, object], ...]: composition.process( _event( composition, "SessionStarted", 0, "event-managed-start", payload={"host_level": "managing"}, ) ) transition = composition.process( _event( composition, "IntentObserved", 1, "event-managed-intent", payload={ "observation_ref": { "provider_id": reference.provider_id, "opaque_id": reference.opaque_id, "content_digest": reference.content_digest, } }, ) ) assert [action.kind for action in transition.actions] == ["PresentBundle"] return transition.actions[0].payload["capabilities"] # type: ignore[return-value] def _material_port(tmp_path: Path) -> AuthenticatedCatalogContentSource: content = b"---\nname: python-tdd\n---\nUse a failing test first.\n" skill = tmp_path / "materials" / "python-tdd" / "SKILL.md" skill.parent.mkdir(parents=True, exist_ok=True) skill.write_bytes(content) return AuthenticatedCatalogContentSource( tmp_path / "materials", [ { "capability_id": "skill:python-tdd", "path": "python-tdd/SKILL.md", "sha256": hashlib.sha256(content).hexdigest(), "size_bytes": len(content), } ], ) def _load_descriptor_for( capability_id: str, snapshot_digest: str, ) -> MaterialDescriptor: kind = capability_id.split(":", 1)[0] identity = MaterialIdentity.create( capability_id=capability_id, kind=kind, content_sha256=_digest(f"content:{capability_id}"), content_bytes=64, ) return MaterialDescriptor.create( capability_id=capability_id, kind=kind, actionability="load", content_sha256=identity.content_sha256, content_bytes=identity.content_bytes, estimated_tokens=16, provenance_digest=snapshot_digest, material_identity_digest=identity.identity_digest, ) @dataclass class _StaticInstallBundlePort: installation_snapshot_digest: str bundles: dict[str, InstallPlanningBundle | None] remove_after_first_lookup: bool = False describe_bundle_calls: list[tuple[str, str]] = field(default_factory=list) def describe_bundle( self, capability_id: str, kind: str, ) -> InstallPlanningBundle | None: self.describe_bundle_calls.append((capability_id, kind)) bundle = self.bundles.get(capability_id) if self.remove_after_first_lookup and len(self.describe_bundle_calls) == 1: self.bundles[capability_id] = None return bundle def describe(self, capability_id: str, kind: str) -> InstallPlanDescriptor | None: bundle = self.describe_bundle(capability_id, kind) return None if bundle is None else bundle.descriptor def prepare(self, *_args: object, **_kwargs: object) -> PreparedInstallPlan: raise RuntimeError("static test install port cannot prepare physical installation") def _install_port() -> tuple[_StaticInstallBundlePort, InstallPlanningBundle]: snapshot_digest = _digest("install-catalog-v1") result_material = MaterialIdentity.create( capability_id="skill:python-tdd", kind="skill", content_sha256=_digest("installed-python-tdd-material"), content_bytes=128, ) descriptor = InstallPlanDescriptor.create( capability_id="skill:python-tdd", kind="skill", installer_id="ctx-skill-installer-v1", plan_digest=_digest("install-plan-v1"), provenance_digest=snapshot_digest, result_material_identity_digest=result_material.identity_digest, ) bundle = InstallPlanningBundle( descriptor=descriptor, result_material=result_material, ) return ( _StaticInstallBundlePort( installation_snapshot_digest=snapshot_digest, bundles={descriptor.capability_id: bundle}, ), bundle, ) def _install_bundle_for( capability_id: str, snapshot_digest: str, ) -> InstallPlanningBundle: kind = capability_id.split(":", 1)[0] result_material = MaterialIdentity.create( capability_id=capability_id, kind=kind, content_sha256=_digest(f"installed:{capability_id}"), content_bytes=128, ) descriptor = InstallPlanDescriptor.create( capability_id=capability_id, kind=kind, installer_id="ctx-skill-installer-v1", plan_digest=_digest(f"install-plan:{capability_id}"), provenance_digest=snapshot_digest, result_material_identity_digest=result_material.identity_digest, ) return InstallPlanningBundle( descriptor=descriptor, result_material=result_material, ) def _open_composition( tmp_path: Path, graph: Path, *, facts: _AuthenticatedFacts | None = None, material_port: AuthenticatedCatalogContentSource | None = None, install_bundle_port: _StaticInstallBundlePort | None = None, journal_name: str = "journal.sqlite3", audit_name: str = "benefit-audit.sqlite3", graph_artifact_sha256: str | None = None, planner_version: str = "ctx-authenticated-net-benefit-planner-v3", policy_store_root: Path | None = None, interactive_install_decision_guard: object | None = None, trusted_utc_now: object | None = None, skill_cas_runtime: SkillCasRuntimeConfig | None = None, agent_file_runtime: AgentFileRuntimeConfig | None = None, ) -> EngineComposition: return open_engine_composition( graph_artifact_path=graph, graph_artifact_sha256=graph_artifact_sha256 or _artifact_digest(graph), journal_path=tmp_path / journal_name, observation_normalizer=_normalizer, benefit_facts_port=facts or _AuthenticatedFacts(), net_benefit_policy=_policy(), catalog_namespace_digest=CATALOG_NAMESPACE_DIGEST, benefit_audit_path=tmp_path / audit_name, material_port=material_port, install_bundle_port=install_bundle_port, planner_version=planner_version, policy_store_root=policy_store_root, interactive_install_decision_guard=interactive_install_decision_guard, # type: ignore[arg-type] trusted_utc_now=trusted_utc_now, # type: ignore[arg-type] skill_cas_runtime=skill_cas_runtime, agent_file_runtime=agent_file_runtime, ) @dataclass(frozen=True) class _ManagedCompositionSetup: registry: ManagedArtifactRegistry handle: ManagedArtifactHandle facts: _AuthenticatedFacts policy: NetBenefitPolicy materials: AuthenticatedCatalogContentSource installs: _StaticInstallBundlePort retrieval_digest: str planning_environment_digest: str legacy_capabilities: tuple[dict[str, object], ...] | None def _managed_composition_setup( tmp_path: Path, *, declared_retrieval_digest: str | None = None, declared_planning_environment_digest: str | None = None, plan_legacy: bool = False, ) -> _ManagedCompositionSetup: graph = _graph_artifact(tmp_path) graph.chmod(0o400) graph_digest = _artifact_digest(graph) facts = _AuthenticatedFacts() policy = _policy() materials = _material_port(tmp_path) installs = _StaticInstallBundlePort( installation_snapshot_digest=_digest("empty-install-catalog-v1"), bundles={}, ) planner_version = "ctx-authenticated-net-benefit-planner-v3" with IndexedGraphCandidateSource( graph, graph_digest, material_port=materials, install_plan_port=installs, ) as source: retrieval_digest = source.catalog_snapshot_digest legacy_capabilities = None with _open_composition( tmp_path, graph, facts=facts, material_port=materials, install_bundle_port=installs, journal_name="legacy-managed-journal.sqlite3", audit_name="legacy-managed-audit.sqlite3", planner_version=planner_version, ) as legacy: planning_environment_digest = legacy.catalog_snapshot_digest if plan_legacy: legacy_capabilities = _plan(legacy) surrogate = _normalizer( ObservationReference( provider_id="test-buffer", opaque_id="observation-1", content_digest=_digest("python-testing-unit"), ), None, ) registry_root = tmp_path / "managed-registry" first_registry = open_managed_artifact_registry(root=registry_root) first_handle = first_registry.ingest_graph_store( graph_store_path=graph, expected_graph_artifact_digest=graph_digest, planning_environment_digest=( declared_planning_environment_digest or planning_environment_digest ), catalog_namespace_digest=CATALOG_NAMESPACE_DIGEST, catalog_retrieval_digest=declared_retrieval_digest or retrieval_digest, benefit_facts_snapshot_digest=facts.benefit_facts_snapshot_digest, benefit_policy_snapshot_digest=policy.policy_digest, material_snapshot_digest=materials.material_snapshot_digest, installation_snapshot_digest=installs.installation_snapshot_digest, observation_surrogate=surrogate, planning_schema_version=planner_version, ) graph.unlink() restarted_registry = open_managed_artifact_registry(root=registry_root) restarted_handle = restarted_registry.reopen( manifest_digest=first_handle.manifest_digest, planning_environment_digest=first_handle.planning_environment_digest, ) return _ManagedCompositionSetup( registry=restarted_registry, handle=restarted_handle, facts=facts, policy=policy, materials=materials, installs=installs, retrieval_digest=retrieval_digest, planning_environment_digest=planning_environment_digest, legacy_capabilities=legacy_capabilities, ) def test_managed_composition_factory_is_artifact_pathless() -> None: parameters = inspect.signature(open_managed_engine_composition).parameters for forbidden in ( "graph_artifact_path", "graph_artifact_sha256", "observation_normalizer", "catalog_namespace_digest", "planner_version", ): assert forbidden not in parameters assert { "registry", "artifact", "journal_path", "benefit_audit_path", "benefit_facts_port", "net_benefit_policy", "material_port", "install_bundle_port", } <= set(parameters) @_REQUIRES_POSIX_MANAGED_REGISTRY def test_managed_composition_reopens_pathless_inputs_with_legacy_equivalence( tmp_path: Path, ) -> None: setup = _managed_composition_setup(tmp_path, plan_legacy=True) with open_managed_engine_composition( registry=setup.registry, artifact=setup.handle, journal_path=tmp_path / "restarted-managed-journal.sqlite3", benefit_audit_path=tmp_path / "restarted-managed-audit.sqlite3", benefit_facts_port=setup.facts, net_benefit_policy=setup.policy, material_port=setup.materials, install_bundle_port=setup.installs, ) as managed: managed_capabilities = _plan_with_observation_reference( managed, setup.handle.observation_reference, ) assert type(managed) is EngineComposition assert managed.catalog_snapshot_digest == setup.planning_environment_digest assert managed_capabilities == setup.legacy_capabilities assert managed.closed is True assert not tuple((tmp_path / "managed-registry").glob("**/.ctx-indexed-snapshot-*")) @_REQUIRES_POSIX_MANAGED_REGISTRY @pytest.mark.skipif(not hasattr(os, "fork"), reason="requires POSIX process restart semantics") def test_managed_composition_reopens_with_a_fresh_handle_after_process_restart( tmp_path: Path, ) -> None: setup = _managed_composition_setup(tmp_path) read_fd, write_fd = os.pipe() child_pid = os.fork() if child_pid == 0: # pragma: no cover - assertions execute in the parent os.close(read_fd) try: registry = open_managed_artifact_registry(root=tmp_path / "managed-registry") handle = registry.reopen( manifest_digest=setup.handle.manifest_digest, planning_environment_digest=setup.handle.planning_environment_digest, ) materials = _material_port(tmp_path) installs = _StaticInstallBundlePort( installation_snapshot_digest=setup.installs.installation_snapshot_digest, bundles={}, ) with open_managed_engine_composition( registry=registry, artifact=handle, journal_path=tmp_path / "child-managed-journal.sqlite3", benefit_audit_path=tmp_path / "child-managed-audit.sqlite3", benefit_facts_port=_AuthenticatedFacts(), net_benefit_policy=_policy(), material_port=materials, install_bundle_port=installs, ) as composition: if composition.catalog_snapshot_digest != setup.planning_environment_digest: raise AssertionError("restarted composition changed planning identity") os.write(write_fd, b"ok") os._exit(0) except BaseException as exc: os.write(write_fd, f"{type(exc).__name__}:{exc}".encode("utf-8")[:2048]) os._exit(1) os.close(write_fd) child_result = os.read(read_fd, 2048) os.close(read_fd) waited_pid, status = os.waitpid(child_pid, 0) assert waited_pid == child_pid assert os.waitstatus_to_exitcode(status) == 0, child_result.decode("utf-8") assert child_result == b"ok" @_REQUIRES_POSIX_MANAGED_REGISTRY @pytest.mark.skipif(not hasattr(os, "fork"), reason="requires POSIX fork semantics") def test_managed_composition_rejects_every_inherited_child_operation( tmp_path: Path, ) -> None: setup = _managed_composition_setup(tmp_path) journal = tmp_path / "fork-inherited-journal.sqlite3" audit = tmp_path / "fork-inherited-audit.sqlite3" composition = open_managed_engine_composition( registry=setup.registry, artifact=setup.handle, journal_path=journal, benefit_audit_path=audit, benefit_facts_port=setup.facts, net_benefit_policy=setup.policy, material_port=setup.materials, install_bundle_port=setup.installs, ) session_started = _event( composition, "SessionStarted", 0, "fork-inherited-start", payload={"host_level": "managing"}, ) read_fd, write_fd = os.pipe() child_pid = os.fork() if child_pid == 0: # pragma: no cover - assertions execute in the parent os.close(read_fd) try: operations = ( lambda: composition.closed, lambda: composition.process(session_started), lambda: composition.snapshot(_scope()), lambda: composition.prepare_managed_query( session_started=session_started, intent_observed=session_started, ), lambda: composition.authorize_exposure( object(), # type: ignore[arg-type] object(), # type: ignore[arg-type] expected_catalog_snapshot_digest=composition.catalog_snapshot_digest, ), lambda: composition.execute_install( object(), # type: ignore[arg-type] object(), # type: ignore[arg-type] expected_policy_digest=_digest("unused-policy"), ), composition.__enter__, lambda: composition.__exit__(None, None, None), composition.close, ) for operation in operations: try: operation() except RuntimeError as exc: if "forked process" not in str(exc): raise else: raise AssertionError("inherited composition operation was accepted") os.write(write_fd, b"ok") os._exit(0) except BaseException as exc: os.write(write_fd, f"{type(exc).__name__}:{exc}".encode("utf-8")[:2048]) os._exit(1) os.close(write_fd) child_result = os.read(read_fd, 2048) os.close(read_fd) waited_pid, status = os.waitpid(child_pid, 0) try: assert waited_pid == child_pid assert os.waitstatus_to_exitcode(status) == 0, child_result.decode("utf-8") assert child_result == b"ok" assert composition.closed is False snapshot = composition.snapshot(_scope()) assert snapshot.revision == 0 assert snapshot.state is None assert not audit.exists() finally: composition.close() @_REQUIRES_POSIX_MANAGED_REGISTRY @pytest.mark.parametrize( ("binding", "message"), [ ("benefit-facts", "benefit facts snapshot"), ("benefit-policy", "benefit policy snapshot"), ("material", "material snapshot"), ("installation", "installation snapshot"), ], ) def test_managed_composition_rejects_authority_snapshot_substitution_before_outputs( tmp_path: Path, binding: str, message: str, ) -> None: setup = _managed_composition_setup(tmp_path) facts = setup.facts policy = setup.policy if binding == "benefit-facts": facts.benefit_facts_snapshot_digest = _digest("substituted-benefit-facts") elif binding == "benefit-policy": policy = NetBenefitPolicy( calibration_digest=_digest("substituted-calibration"), minimum_relevance_ppm=1, ) elif binding == "material": setup.materials.material_snapshot_digest = _digest("substituted-materials") else: setup.installs.installation_snapshot_digest = _digest("substituted-installs") journal = tmp_path / f"{binding}-managed-journal.sqlite3" audit = tmp_path / f"{binding}-managed-audit.sqlite3" with pytest.raises(ValueError, match=message): open_managed_engine_composition( registry=setup.registry, artifact=setup.handle, journal_path=journal, benefit_audit_path=audit, benefit_facts_port=facts, net_benefit_policy=policy, material_port=setup.materials, install_bundle_port=setup.installs, ) assert not journal.exists() assert not audit.exists() assert not tuple((tmp_path / "managed-registry").glob("**/.ctx-indexed-snapshot-*")) @_REQUIRES_POSIX_MANAGED_REGISTRY @pytest.mark.parametrize( ("missing_port", "message"), [("material", "material_port.*contract"), ("installation", "install bundle contract")], ) def test_managed_composition_requires_both_concrete_authority_ports( tmp_path: Path, missing_port: str, message: str, ) -> None: setup = _managed_composition_setup(tmp_path) with pytest.raises(TypeError, match=message): open_managed_engine_composition( registry=setup.registry, artifact=setup.handle, journal_path=tmp_path / "missing-port-journal.sqlite3", benefit_audit_path=tmp_path / "missing-port-audit.sqlite3", benefit_facts_port=setup.facts, net_benefit_policy=setup.policy, material_port=(None if missing_port == "material" else setup.materials), # type: ignore[arg-type] install_bundle_port=(None if missing_port == "installation" else setup.installs), # type: ignore[arg-type] ) @_REQUIRES_POSIX_MANAGED_REGISTRY def test_managed_composition_rejects_a_foreign_registry_handle_before_outputs( tmp_path: Path, ) -> None: setup = _managed_composition_setup(tmp_path) foreign = open_managed_artifact_registry(root=tmp_path / "foreign-registry") journal = tmp_path / "foreign-journal.sqlite3" audit = tmp_path / "foreign-audit.sqlite3" with pytest.raises(ManagedArtifactRegistryError, match="not issued"): open_managed_engine_composition( registry=foreign, artifact=setup.handle, journal_path=journal, benefit_audit_path=audit, benefit_facts_port=setup.facts, net_benefit_policy=setup.policy, material_port=setup.materials, install_bundle_port=setup.installs, ) assert not journal.exists() assert not audit.exists() @_REQUIRES_POSIX_MANAGED_REGISTRY def test_managed_composition_recomputes_catalog_retrieval_before_outputs( tmp_path: Path, ) -> None: setup = _managed_composition_setup( tmp_path, declared_retrieval_digest=_digest("substituted-retrieval"), ) journal = tmp_path / "retrieval-journal.sqlite3" audit = tmp_path / "retrieval-audit.sqlite3" with pytest.raises(ManagedArtifactRegistryError, match="catalog retrieval digest"): open_managed_engine_composition( registry=setup.registry, artifact=setup.handle, journal_path=journal, benefit_audit_path=audit, benefit_facts_port=setup.facts, net_benefit_policy=setup.policy, material_port=setup.materials, install_bundle_port=setup.installs, ) assert not journal.exists() assert not audit.exists() assert not tuple((tmp_path / "managed-registry").glob("**/.ctx-indexed-snapshot-*")) @_REQUIRES_POSIX_MANAGED_REGISTRY def test_managed_composition_recomputes_planning_environment_before_outputs( tmp_path: Path, ) -> None: setup = _managed_composition_setup( tmp_path, declared_planning_environment_digest=_digest("substituted-environment"), ) journal = tmp_path / "environment-journal.sqlite3" audit = tmp_path / "environment-audit.sqlite3" with pytest.raises(ValueError, match="planning environment"): open_managed_engine_composition( registry=setup.registry, artifact=setup.handle, journal_path=journal, benefit_audit_path=audit, benefit_facts_port=setup.facts, net_benefit_policy=setup.policy, material_port=setup.materials, install_bundle_port=setup.installs, ) assert not journal.exists() assert not audit.exists() assert not tuple((tmp_path / "managed-registry").glob("**/.ctx-indexed-snapshot-*")) @_REQUIRES_POSIX_MANAGED_REGISTRY def test_managed_composition_temporal_fact_drift_leaves_no_output_store( tmp_path: Path, ) -> None: setup = _managed_composition_setup(tmp_path) class _TemporallyChangingFacts: def __init__(self) -> None: self.digest_reads = 0 @property def benefit_facts_snapshot_digest(self) -> str: self.digest_reads += 1 if self.digest_reads <= 3: return setup.handle.benefit_facts_snapshot_digest return _digest("temporally-substituted-benefit-facts") def benefit_candidate( self, _presentation: CapabilityCandidate, _observation: WorkObservation, ) -> None: raise AssertionError("composition validation must not query benefit facts") facts = _TemporallyChangingFacts() journal = tmp_path / "temporal-drift-journal.sqlite3" audit = tmp_path / "temporal-drift-audit.sqlite3" with pytest.raises(ValueError, match="planning environment changed"): open_managed_engine_composition( registry=setup.registry, artifact=setup.handle, journal_path=journal, benefit_audit_path=audit, benefit_facts_port=facts, # type: ignore[arg-type] net_benefit_policy=setup.policy, material_port=setup.materials, install_bundle_port=setup.installs, ) assert facts.digest_reads == 4 assert not journal.exists() assert not audit.exists() assert not tuple((tmp_path / "managed-registry").glob("**/.ctx-indexed-snapshot-*")) @_REQUIRES_POSIX_MANAGED_REGISTRY def test_managed_composition_preserves_binding_error_when_cleanup_also_fails( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: setup = _managed_composition_setup( tmp_path, declared_retrieval_digest=_digest("substituted-retrieval"), ) original_close = IndexedGraphCandidateSource.close def cleanup_then_fail(source: IndexedGraphCandidateSource) -> None: original_close(source) raise OSError("injected cleanup failure") monkeypatch.setattr(IndexedGraphCandidateSource, "close", cleanup_then_fail) with pytest.raises( ManagedArtifactRegistryError, match="catalog retrieval digest", ) as captured: open_managed_engine_composition( registry=setup.registry, artifact=setup.handle, journal_path=tmp_path / "cleanup-journal.sqlite3", benefit_audit_path=tmp_path / "cleanup-audit.sqlite3", benefit_facts_port=setup.facts, net_benefit_policy=setup.policy, material_port=setup.materials, install_bundle_port=setup.installs, ) assert captured.value.__notes__ == ["managed indexed-source cleanup also failed with OSError"] def test_composition_plans_authenticated_loadable_material(tmp_path: Path) -> None: graph = _graph_artifact(tmp_path) facts = _AuthenticatedFacts() audit_path = tmp_path / "benefit-audit.sqlite3" with _open_composition( tmp_path, graph, facts=facts, material_port=_material_port(tmp_path), ) as composition: capabilities = _plan(composition) snapshot = composition.snapshot(_scope()) assert len(capabilities) == 1 assert capabilities[0]["capability_id"] == "skill:python-tdd" assert capabilities[0]["actionability"] == "load" assert capabilities[0]["install_descriptor_digest"] is None assert capabilities[0]["install_plan_digest"] is None assert capabilities[0]["authority"]["type"] == "load" # type: ignore[index] assert capabilities[0]["benefit"]["tier"] == "executable" # type: ignore[index] # The schema-v3 adapter validates every authenticated read again before # emitting its first plan, so unchanged snapshot digests cannot hide drift. assert facts.calls == ["skill:python-tdd", "skill:python-tdd"] assert snapshot.state is not None assert isinstance(snapshot.state.committed_plan, CommittedPlanV3) audit = snapshot.state.committed_plan.benefit_audit assert audit is not None persisted = SQLiteBenefitAuditStore(audit_path).load(audit.result_digest) assert persisted.result_digest == audit.result_digest assert persisted.policy_digest == _policy().policy_digest def test_composition_prepares_one_safe_plan_under_owned_graph_lifetime( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) with _open_composition(tmp_path, graph) as composition: session_started = _event( composition, "SessionStarted", 0, "managed-start", payload={"host_level": "managing"}, ) intent_observed = _event( composition, "IntentObserved", 1, "managed-intent", payload={ "observation_ref": { "provider_id": "test-buffer", "opaque_id": "managed-observation", "content_digest": _digest("python-testing-unit"), } }, ) prepared = composition.prepare_managed_query( session_started=session_started, intent_observed=intent_observed, ) snapshot = composition.snapshot(_scope()) assert type(prepared) is PreparedManagedQuery assert prepared.journal_revision == snapshot.revision == 2 assert prepared.journal_record_digest == snapshot.record_digest assert tuple(item.capability_id for item in prepared.selections) == ("skill:python-tdd",) assert not hasattr(prepared.selections[0], "authority") def test_composition_prepares_one_global_cross_type_plan_from_real_graph( tmp_path: Path, ) -> None: graph = _cross_type_graph_artifact(tmp_path) with _open_composition(tmp_path, graph) as composition: prepared = composition.prepare_managed_query( session_started=_event( composition, "SessionStarted", 0, "cross-type-start", payload={"host_level": "managing"}, ), intent_observed=_event( composition, "IntentObserved", 1, "cross-type-intent", payload={ "observation_ref": { "provider_id": "test-buffer", "opaque_id": "cross-type-observation", "content_digest": _digest("python-testing-unit"), } }, ), ) assert len(prepared.selections) == 4 assert {item.kind for item in prepared.selections} == { "skill", "agent", "mcp-server", "harness", } assert {item.actionability for item in prepared.selections} == {"manual"} def test_composition_skips_malformed_load_authority_and_keeps_valid_peer( tmp_path: Path, ) -> None: graph = _two_skill_graph_artifact(tmp_path) bad_capability_id = "skill:python-bad" good_capability_id = "skill:python-good" snapshot_digest = _digest("mixed-material-snapshot") identity = MaterialIdentity.create( capability_id=good_capability_id, kind="skill", content_sha256=_digest("python-good-content"), content_bytes=64, ) good_descriptor = MaterialDescriptor.create( capability_id=good_capability_id, kind="skill", actionability="load", content_sha256=identity.content_sha256, content_bytes=identity.content_bytes, estimated_tokens=16, provenance_digest=snapshot_digest, material_identity_digest=identity.identity_digest, ) class _MixedMaterialPort: material_snapshot_digest = snapshot_digest def describe(self, capability_id: str, _kind: str) -> MaterialDescriptor: if capability_id == bad_capability_id: return cast(MaterialDescriptor, object()) return good_descriptor def prepare(self, *_args: object, **_kwargs: object) -> None: raise AssertionError("planning must not prepare material") with _open_composition( tmp_path, graph, material_port=cast(AuthenticatedCatalogContentSource, _MixedMaterialPort()), ) as composition: capabilities = _plan(composition) assert [row["capability_id"] for row in capabilities] == [good_capability_id] assert capabilities[0]["authority"]["type"] == "load" # type: ignore[index] assert all(row["capability_id"] != bad_capability_id for row in capabilities) def test_pinned_material_port_treats_valid_to_malformed_as_global_drift() -> None: capability_id = "skill:python-bad" snapshot_digest = _digest("changing-material-snapshot") identity = MaterialIdentity.create( capability_id=capability_id, kind="skill", content_sha256=_digest("changing-material-content"), content_bytes=64, ) descriptor = MaterialDescriptor.create( capability_id=capability_id, kind="skill", actionability="load", content_sha256=identity.content_sha256, content_bytes=identity.content_bytes, estimated_tokens=16, provenance_digest=snapshot_digest, material_identity_digest=identity.identity_digest, ) class _ChangingMaterialPort: material_snapshot_digest = snapshot_digest malformed = False def describe(self, _capability_id: str, _kind: str) -> MaterialDescriptor: if self.malformed: return cast(MaterialDescriptor, object()) return descriptor def prepare(self, *_args: object, **_kwargs: object) -> None: raise AssertionError("planning must not prepare material") port = _ChangingMaterialPort() pinned = composition_module._PinnedMaterialPort(cast(AuthenticatedCatalogContentSource, port)) assert pinned.describe(capability_id, "skill") == descriptor port.malformed = True with pytest.raises(ValueError, match="changed within"): pinned.describe(capability_id, "skill") def test_pinned_material_port_remembers_delegate_candidate_local_exceptions() -> None: capability_id = "skill:python-bad" snapshot_digest = _digest("exception-material-snapshot") identity = MaterialIdentity.create( capability_id=capability_id, kind="skill", content_sha256=_digest("exception-material-content"), content_bytes=64, ) descriptor = MaterialDescriptor.create( capability_id=capability_id, kind="skill", actionability="load", content_sha256=identity.content_sha256, content_bytes=identity.content_bytes, estimated_tokens=16, provenance_digest=snapshot_digest, material_identity_digest=identity.identity_digest, ) class _ExceptionMaterialPort: material_snapshot_digest = snapshot_digest def __init__(self, *, unavailable: bool) -> None: self.unavailable = unavailable def describe(self, _capability_id: str, _kind: str) -> MaterialDescriptor: if self.unavailable: raise CandidateAuthorityUnavailable("injected material failure") return descriptor def prepare(self, *_args: object, **_kwargs: object) -> None: raise AssertionError("planning must not prepare material") exception_first = _ExceptionMaterialPort(unavailable=True) pinned_exception_first = composition_module._PinnedMaterialPort( cast(AuthenticatedCatalogContentSource, exception_first) ) for _ in range(2): with pytest.raises(CandidateAuthorityUnavailable, match="injected"): pinned_exception_first.describe(capability_id, "skill") exception_first.unavailable = False with pytest.raises(ValueError, match="changed within"): pinned_exception_first.describe(capability_id, "skill") valid_first = _ExceptionMaterialPort(unavailable=False) pinned_valid_first = composition_module._PinnedMaterialPort( cast(AuthenticatedCatalogContentSource, valid_first) ) assert pinned_valid_first.describe(capability_id, "skill") == descriptor valid_first.unavailable = True with pytest.raises(ValueError, match="changed within"): pinned_valid_first.describe(capability_id, "skill") @pytest.mark.parametrize("returned_value", [None, object()], ids=["none", "object"]) def test_pinned_material_port_distinguishes_exception_from_malformed_return( returned_value: object, ) -> None: capability_id = "skill:python-bad" snapshot_digest = _digest("exception-vs-malformed-material") class _ExceptionOrMalformedMaterialPort: material_snapshot_digest = snapshot_digest def __init__(self, *, raises: bool) -> None: self.raises = raises def describe(self, _capability_id: str, _kind: str) -> MaterialDescriptor: if self.raises: raise CandidateAuthorityUnavailable("injected material failure") return cast(MaterialDescriptor, returned_value) def prepare(self, *_args: object, **_kwargs: object) -> None: raise AssertionError("planning must not prepare material") exception_first = _ExceptionOrMalformedMaterialPort(raises=True) pinned_exception_first = composition_module._PinnedMaterialPort( cast(AuthenticatedCatalogContentSource, exception_first) ) with pytest.raises(CandidateAuthorityUnavailable, match="injected"): pinned_exception_first.describe(capability_id, "skill") exception_first.raises = False with pytest.raises(ValueError, match="changed within"): pinned_exception_first.describe(capability_id, "skill") malformed_first = _ExceptionOrMalformedMaterialPort(raises=False) pinned_malformed_first = composition_module._PinnedMaterialPort( cast(AuthenticatedCatalogContentSource, malformed_first) ) with pytest.raises(CandidateAuthorityUnavailable, match="does not match"): pinned_malformed_first.describe(capability_id, "skill") malformed_first.raises = True with pytest.raises(ValueError, match="changed within"): pinned_malformed_first.describe(capability_id, "skill") @pytest.mark.parametrize( ("first_value", "second_value"), [(None, object()), (object(), None)], ids=["none-to-object", "object-to-none"], ) def test_pinned_material_port_distinguishes_none_from_malformed_object( first_value: object, second_value: object, ) -> None: capability_id = "skill:python-bad" class _ChangingMalformedMaterialPort: material_snapshot_digest = _digest("none-vs-malformed-material") def __init__(self) -> None: self.value = first_value def describe(self, _capability_id: str, _kind: str) -> MaterialDescriptor: return cast(MaterialDescriptor, self.value) def prepare(self, *_args: object, **_kwargs: object) -> None: raise AssertionError("planning must not prepare material") delegate = _ChangingMalformedMaterialPort() pinned = composition_module._PinnedMaterialPort( cast(AuthenticatedCatalogContentSource, delegate) ) with pytest.raises(CandidateAuthorityUnavailable, match="does not match"): pinned.describe(capability_id, "skill") delegate.value = second_value with pytest.raises(ValueError, match="changed within"): pinned.describe(capability_id, "skill") @pytest.mark.parametrize("initially_unavailable", [False, True]) def test_composed_material_exception_transition_is_global_across_observations( tmp_path: Path, initially_unavailable: bool, ) -> None: graph = _two_skill_graph_artifact(tmp_path) bad_capability_id = "skill:python-bad" good_capability_id = "skill:python-good" snapshot_digest = _digest("observation-material-snapshot") descriptors = { capability_id: _load_descriptor_for(capability_id, snapshot_digest) for capability_id in (bad_capability_id, good_capability_id) } class _ObservationMaterialPort: material_snapshot_digest = snapshot_digest unavailable = initially_unavailable def describe(self, capability_id: str, _kind: str) -> MaterialDescriptor: if self.unavailable and capability_id == bad_capability_id: raise CandidateAuthorityUnavailable("injected material failure") return descriptors[capability_id] def prepare(self, *_args: object, **_kwargs: object) -> None: raise AssertionError("planning must not prepare material") delegate = _ObservationMaterialPort() pinned = composition_module._PinnedMaterialPort( cast(AuthenticatedCatalogContentSource, delegate) ) first_observation = WorkObservation( signals=("python", "testing", "unit"), languages=("python",), ) second_observation = WorkObservation( signals=("python", "review", "testing", "unit"), languages=("python",), ) with IndexedGraphCandidateSource( graph, _artifact_digest(graph), material_port=pinned, ) as source: first = {item.capability_id: item for item in source.retrieve(first_observation)} assert good_capability_id in first assert (bad_capability_id in first) is not initially_unavailable delegate.unavailable = not initially_unavailable with pytest.raises(CandidateSourceUnavailable, match="material descriptor retrieval"): source.retrieve(second_observation) def test_composition_preserves_manual_advice_and_zero_selection_abstention( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) with _open_composition(tmp_path, graph) as composition: capability = _plan(composition)[0] assert capability["actionability"] == "manual" assert capability["authority"] == {"type": "manual"} assert capability["benefit"]["tier"] == "advisory" # type: ignore[index] low_facts = _AuthenticatedFacts(expected_task_benefit_ppm=0) with _open_composition( tmp_path, graph, facts=low_facts, journal_name="abstained-journal.sqlite3", audit_name="abstained-audit.sqlite3", ) as composition: composition.process( _event( composition, "SessionStarted", 0, "abstained-start", payload={"host_level": "managing"}, ) ) transition = composition.process( _event( composition, "IntentObserved", 1, "abstained-intent", payload={ "observation_ref": { "provider_id": "test-buffer", "opaque_id": "abstained-observation", "content_digest": _digest("abstained-observation"), } }, ) ) snapshot = composition.snapshot(_scope()) assert transition.actions == () assert transition.diagnostics[-1]["code"] == "below-net-benefit" assert snapshot.state is not None assert isinstance(snapshot.state.committed_plan, CommittedPlanV3) assert snapshot.state.committed_plan.status == "abstained" assert snapshot.state.committed_plan.capabilities == () def test_composition_fails_closed_without_exact_authenticated_benefit_facts( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) with _open_composition( tmp_path, graph, facts=_AuthenticatedFacts(missing=True), ) as composition: composition.process( _event( composition, "SessionStarted", 0, "missing-facts-start", payload={"host_level": "managing"}, ) ) with pytest.raises(ReplayValidationError, match="decision planning failed"): composition.process( _event( composition, "IntentObserved", 1, "missing-facts-intent", payload={ "observation_ref": { "provider_id": "test-buffer", "opaque_id": "missing-facts-observation", "content_digest": _digest("missing-facts-observation"), } }, ) ) def test_composition_rejects_material_snapshot_drift( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) material_port = _material_port(tmp_path) with _open_composition( tmp_path, graph, material_port=material_port, ) as composition: composition.process( _event( composition, "SessionStarted", 0, "event-start", payload={"host_level": "managing"}, ) ) material_port.material_snapshot_digest = _digest("changed-material-snapshot") transition = composition.process( _event( composition, "IntentObserved", 1, "event-after-material-change", payload={ "observation_ref": { "provider_id": "test-buffer", "opaque_id": "observation-after-change", "content_digest": _digest("python-testing-unit-after-change"), } }, ) ) assert {diagnostic["code"] for diagnostic in transition.diagnostics} == {"catalog-unavailable"} def test_composition_fails_closed_when_authenticated_fact_snapshot_drifts( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) facts = _AuthenticatedFacts() with _open_composition(tmp_path, graph, facts=facts) as composition: composition.process( _event( composition, "SessionStarted", 0, "fact-drift-start", payload={"host_level": "managing"}, ) ) facts.benefit_facts_snapshot_digest = _digest("substituted-benefit-facts") with pytest.raises(ReplayValidationError, match="decision planning failed"): composition.process( _event( composition, "IntentObserved", 1, "fact-drift-intent", payload={ "observation_ref": { "provider_id": "test-buffer", "opaque_id": "fact-drift-observation", "content_digest": _digest("fact-drift-observation"), } }, ) ) def test_composition_plans_absent_capability_from_typed_install_port(tmp_path: Path) -> None: graph = _graph_artifact(tmp_path) install_port, bundle = _install_port() with _open_composition( tmp_path, graph, install_bundle_port=install_port, ) as composition: capabilities = _plan(composition) assert len(capabilities) == 1 assert capabilities[0]["actionability"] == "install" assert capabilities[0]["install_descriptor_digest"] == bundle.descriptor.descriptor_digest assert capabilities[0]["install_plan_digest"] == bundle.descriptor.plan_digest assert capabilities[0]["authority"] == { "type": "install", "descriptor": bundle.descriptor.to_dict(), "result_material": bundle.result_material.to_dict(), } def test_composition_skips_malformed_install_authority_and_keeps_valid_peer( tmp_path: Path, ) -> None: graph = _two_skill_graph_artifact(tmp_path) bad_capability_id = "skill:python-bad" good_capability_id = "skill:python-good" snapshot_digest = _digest("mixed-install-snapshot") good_bundle = _install_bundle_for(good_capability_id, snapshot_digest) port = _StaticInstallBundlePort( installation_snapshot_digest=snapshot_digest, bundles={ bad_capability_id: cast(InstallPlanningBundle, object()), good_capability_id: good_bundle, }, ) with _open_composition( tmp_path, graph, install_bundle_port=port, ) as composition: capabilities = _plan(composition) assert [row["capability_id"] for row in capabilities] == [good_capability_id] assert capabilities[0]["authority"]["type"] == "install" # type: ignore[index] assert all(row["capability_id"] != bad_capability_id for row in capabilities) def test_pinned_install_port_treats_valid_to_malformed_as_global_drift() -> None: capability_id = "skill:python-bad" snapshot_digest = _digest("changing-install-snapshot") bundle = _install_bundle_for(capability_id, snapshot_digest) port = _StaticInstallBundlePort( installation_snapshot_digest=snapshot_digest, bundles={capability_id: bundle}, ) pinned = composition_module._PinnedInstallBundlePort(port) assert pinned.describe_bundle(capability_id, "skill") == bundle port.bundles[capability_id] = cast(InstallPlanningBundle, object()) with pytest.raises(ValueError, match="changed within"): pinned.describe_bundle(capability_id, "skill") def test_pinned_install_port_remembers_delegate_candidate_local_exceptions() -> None: capability_id = "skill:python-bad" snapshot_digest = _digest("exception-install-snapshot") bundle = _install_bundle_for(capability_id, snapshot_digest) class _ExceptionInstallPort(_StaticInstallBundlePort): unavailable: bool def describe_bundle( self, candidate_id: str, kind: str, ) -> InstallPlanningBundle | None: if self.unavailable: raise CandidateAuthorityUnavailable("injected install failure") return super().describe_bundle(candidate_id, kind) exception_first = _ExceptionInstallPort( installation_snapshot_digest=snapshot_digest, bundles={capability_id: bundle}, ) exception_first.unavailable = True pinned_exception_first = composition_module._PinnedInstallBundlePort(exception_first) for _ in range(2): with pytest.raises(CandidateAuthorityUnavailable, match="injected"): pinned_exception_first.describe_bundle(capability_id, "skill") exception_first.unavailable = False with pytest.raises(ValueError, match="changed within"): pinned_exception_first.describe_bundle(capability_id, "skill") valid_first = _ExceptionInstallPort( installation_snapshot_digest=snapshot_digest, bundles={capability_id: bundle}, ) valid_first.unavailable = False pinned_valid_first = composition_module._PinnedInstallBundlePort(valid_first) assert pinned_valid_first.describe_bundle(capability_id, "skill") == bundle valid_first.unavailable = True with pytest.raises(ValueError, match="changed within"): pinned_valid_first.describe_bundle(capability_id, "skill") @pytest.mark.parametrize("returned_value", [None, object()], ids=["none", "object"]) def test_pinned_install_port_distinguishes_exception_from_returned_value( returned_value: object, ) -> None: capability_id = "skill:python-bad" snapshot_digest = _digest("exception-vs-returned-install") class _ExceptionOrReturnedInstallPort: installation_snapshot_digest = snapshot_digest def __init__(self, *, raises: bool) -> None: self.raises = raises def describe_bundle( self, _capability_id: str, _kind: str, ) -> InstallPlanningBundle | None: if self.raises: raise CandidateAuthorityUnavailable("injected install failure") return cast(InstallPlanningBundle | None, returned_value) exception_first = _ExceptionOrReturnedInstallPort(raises=True) pinned_exception_first = composition_module._PinnedInstallBundlePort( cast(_StaticInstallBundlePort, exception_first) ) with pytest.raises(CandidateAuthorityUnavailable, match="injected"): pinned_exception_first.describe_bundle(capability_id, "skill") exception_first.raises = False with pytest.raises(ValueError, match="changed within"): pinned_exception_first.describe_bundle(capability_id, "skill") returned_first = _ExceptionOrReturnedInstallPort(raises=False) pinned_returned_first = composition_module._PinnedInstallBundlePort( cast(_StaticInstallBundlePort, returned_first) ) if returned_value is None: assert pinned_returned_first.describe_bundle(capability_id, "skill") is None else: with pytest.raises(CandidateAuthorityUnavailable, match="does not match"): pinned_returned_first.describe_bundle(capability_id, "skill") returned_first.raises = True with pytest.raises(ValueError, match="changed within"): pinned_returned_first.describe_bundle(capability_id, "skill") @pytest.mark.parametrize("initially_unavailable", [False, True]) def test_composed_install_exception_transition_is_global_across_observations( tmp_path: Path, initially_unavailable: bool, ) -> None: graph = _two_skill_graph_artifact(tmp_path) bad_capability_id = "skill:python-bad" good_capability_id = "skill:python-good" snapshot_digest = _digest("observation-install-snapshot") class _ObservationInstallPort(_StaticInstallBundlePort): unavailable = initially_unavailable def describe_bundle( self, capability_id: str, kind: str, ) -> InstallPlanningBundle | None: if self.unavailable and capability_id == bad_capability_id: raise CandidateAuthorityUnavailable("injected install failure") return super().describe_bundle(capability_id, kind) delegate = _ObservationInstallPort( installation_snapshot_digest=snapshot_digest, bundles={ capability_id: _install_bundle_for(capability_id, snapshot_digest) for capability_id in (bad_capability_id, good_capability_id) }, ) pinned = composition_module._PinnedInstallBundlePort(delegate) first_observation = WorkObservation( signals=("python", "testing", "unit"), languages=("python",), ) second_observation = WorkObservation( signals=("python", "review", "testing", "unit"), languages=("python",), ) with IndexedGraphCandidateSource( graph, _artifact_digest(graph), install_plan_port=pinned, ) as source: first = {item.capability_id: item for item in source.retrieve(first_observation)} assert good_capability_id in first assert (bad_capability_id in first) is not initially_unavailable delegate.unavailable = not initially_unavailable with pytest.raises(CandidateSourceUnavailable, match="install descriptor retrieval"): source.retrieve(second_observation) def test_composition_rejects_install_authority_removed_between_retrieval_and_planning( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) install_port, _bundle = _install_port() install_port.remove_after_first_lookup = True with _open_composition( tmp_path, graph, install_bundle_port=install_port, ) as composition: composition.process( _event( composition, "SessionStarted", 0, "removed-install-start", payload={"host_level": "managing"}, ) ) with pytest.raises(ReplayValidationError, match="decision planning failed"): composition.process( _event( composition, "IntentObserved", 1, "removed-install-intent", payload={ "observation_ref": { "provider_id": "test-buffer", "opaque_id": "removed-install-observation", "content_digest": _digest("removed-install-observation"), } }, ) ) def test_composition_wires_current_policy_and_exact_descriptor_for_auto_grant( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) install_port, bundle = _install_port() policy_root = tmp_path / "install-policy" policy = InstallConsentPolicy(skill_mode="preapproved-auto") assert persist_install_policy(policy, policy_root) == policy.policy_digest with _open_composition( tmp_path, graph, install_bundle_port=install_port, policy_store_root=policy_root, trusted_utc_now=_trusted_now, ) as composition: capability = _plan(composition)[0] consent = composition.process( _event( composition, "ReassessmentRequested", 2, "event-desired", payload={ "owner_id": "runtime-owner-1", "policy_snapshot_digest": policy.policy_digest, "desired_capabilities": [ { "capability_id": capability["capability_id"], "source_digest": capability["catalog_entry_digest"], "lease_id": "lease-1", "kind": capability["kind"], "actionability": capability["actionability"], "install_descriptor_digest": capability["install_descriptor_digest"], "install_plan_digest": capability["install_plan_digest"], } ], }, ) ) request = consent.actions[0] assert request.kind == "RequestConsent" granted = composition.process( _event( composition, "UserDecision", 3, "event-auto-grant", payload={ "consent_id": request.consent_id or "", "decision": "granted", "decision_basis": "preapproved-policy", "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" ], }, ) ) assert [action.kind for action in granted.actions] == ["InstallCapability"] assert install_port.describe_bundle_calls[-1] == ( bundle.descriptor.capability_id, bundle.descriptor.kind, ) @pytest.mark.skipif(os.name == "nt", reason="built-in skill CAS is POSIX-only") def test_composition_owns_and_executes_built_in_skill_cas_driver(tmp_path: Path) -> None: graph = _graph_artifact(tmp_path) body = "---\nname: python-tdd\ndescription: composition CAS test\n---\nTest first.\n" encoded = body.encode("utf-8") snapshot_digest = _digest("install-catalog-cas") material = MaterialIdentity.create( capability_id="skill:python-tdd", kind="skill", content_sha256=hashlib.sha256(encoded).hexdigest(), content_bytes=len(encoded), ) descriptor = InstallPlanDescriptor.create( capability_id=material.capability_id, kind=material.kind, installer_id="ctx-skill-installer-v1", plan_digest=_digest("install-plan-cas"), provenance_digest=snapshot_digest, result_material_identity_digest=material.identity_digest, ) install_port = _StaticInstallBundlePort( installation_snapshot_digest=snapshot_digest, bundles={ descriptor.capability_id: InstallPlanningBundle( descriptor=descriptor, result_material=material, ) }, ) skill_root = tmp_path / "ctx-private" / "skills" skill_root.mkdir(parents=True, mode=0o700) skill_root.chmod(0o700) load_calls: list[str] = [] class _BodySource: def load( self, request: InstallDriverRequest, expected_material: MaterialIdentity, ) -> str: load_calls.append(request.action.action_id) assert expected_material == material return body policy_root = tmp_path / "install-policy-cas" policy = InstallConsentPolicy(skill_mode="preapproved-auto") persist_install_policy(policy, policy_root) runtime = SkillCasRuntimeConfig( skill_store_root=skill_root, body_source=_BodySource(), installer_id=descriptor.installer_id, host_identity_digest=_digest("composition-host"), ) with _open_composition( tmp_path, graph, install_bundle_port=install_port, policy_store_root=policy_root, trusted_utc_now=_trusted_now, skill_cas_runtime=runtime, ) as composition: capability = _plan(composition)[0] consent = composition.process( _event( composition, "ReassessmentRequested", 2, "event-cas-desired", payload={ "owner_id": "runtime-owner-cas", "policy_snapshot_digest": policy.policy_digest, "desired_capabilities": [ { "capability_id": capability["capability_id"], "source_digest": capability["catalog_entry_digest"], "lease_id": "lease-cas", "kind": capability["kind"], "actionability": capability["actionability"], "install_descriptor_digest": capability["install_descriptor_digest"], "install_plan_digest": capability["install_plan_digest"], } ], }, ) ) request = consent.actions[0] granted = composition.process( _event( composition, "UserDecision", 3, "event-cas-grant", payload={ "consent_id": request.consent_id or "", "decision": "granted", "decision_basis": "preapproved-policy", "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" ], }, ) ) install = granted.actions[0] snapshot = composition.snapshot(_scope()) assert snapshot.state is not None state = snapshot.state.capability(descriptor.capability_id) assert isinstance(state, CapabilityStateV3) report = composition.execute_install( install, state.selection.selection, expected_policy_digest=policy.policy_digest, ) assert report.outcome == "applied" assert report.settled assert load_calls == [install.action_id] assert (skill_root / material.content_sha256).read_text(encoding="utf-8") == body @pytest.mark.skipif(os.name == "nt", reason="built-in POSIX actuators are disabled") def test_composition_routes_agent_with_skill_and_agent_drivers_registered( tmp_path: Path, ) -> None: graph = _agent_graph_artifact(tmp_path) body = ( "---\nname: reviewer\ndescription: composition agent test\n---\nReview the current task.\n" ) encoded = body.encode("utf-8") snapshot_digest = _digest("install-catalog-agent") material = MaterialIdentity.create( capability_id="agent:reviewer", kind="agent", content_sha256=hashlib.sha256(encoded).hexdigest(), content_bytes=len(encoded), ) shared_installer_id = "ctx-shared-text-installer-v1" descriptor = InstallPlanDescriptor.create( capability_id=material.capability_id, kind=material.kind, installer_id=shared_installer_id, plan_digest=_digest("install-plan-agent"), provenance_digest=snapshot_digest, result_material_identity_digest=material.identity_digest, ) install_port = _StaticInstallBundlePort( installation_snapshot_digest=snapshot_digest, bundles={ descriptor.capability_id: InstallPlanningBundle( descriptor=descriptor, result_material=material, ) }, ) private_root = tmp_path / "ctx-private" private_root.mkdir(mode=0o700) private_root.chmod(0o700) skill_root = private_root / "skills" agent_root = private_root / "inactive-agents" for root in (skill_root, agent_root): root.mkdir(mode=0o700) root.chmod(0o700) agent_load_calls: list[str] = [] class _SkillBodySource: def load( self, _request: InstallDriverRequest, _material: MaterialIdentity, ) -> str: raise AssertionError("agent install must not connect the skill driver") class _AgentBodySource: def load( self, request: InstallDriverRequest, expected_material: MaterialIdentity, ) -> str: agent_load_calls.append(request.action.action_id) assert expected_material == material return body policy_root = tmp_path / "install-policy-agent" policy = InstallConsentPolicy(agent_mode="preapproved-auto") persist_install_policy(policy, policy_root) skill_runtime = SkillCasRuntimeConfig( skill_store_root=skill_root, body_source=_SkillBodySource(), installer_id=shared_installer_id, host_identity_digest=_digest("composition-host"), ) agent_runtime = AgentFileRuntimeConfig( inactive_agent_root=agent_root, body_source=_AgentBodySource(), installer_id=shared_installer_id, host_identity_digest=_digest("composition-host"), ) with _open_composition( tmp_path, graph, install_bundle_port=install_port, policy_store_root=policy_root, trusted_utc_now=_trusted_now, skill_cas_runtime=skill_runtime, agent_file_runtime=agent_runtime, ) as composition: capability = _plan(composition)[0] consent = composition.process( _event( composition, "ReassessmentRequested", 2, "event-agent-desired", payload={ "owner_id": "runtime-owner-agent", "policy_snapshot_digest": policy.policy_digest, "desired_capabilities": [ { "capability_id": capability["capability_id"], "source_digest": capability["catalog_entry_digest"], "lease_id": "lease-agent", "kind": capability["kind"], "actionability": capability["actionability"], "install_descriptor_digest": capability["install_descriptor_digest"], "install_plan_digest": capability["install_plan_digest"], } ], }, ) ) request = consent.actions[0] granted = composition.process( _event( composition, "UserDecision", 3, "event-agent-grant", payload={ "consent_id": request.consent_id or "", "decision": "granted", "decision_basis": "preapproved-policy", "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" ], }, ) ) install = granted.actions[0] snapshot = composition.snapshot(_scope()) assert snapshot.state is not None state = snapshot.state.capability(descriptor.capability_id) assert isinstance(state, CapabilityStateV3) report = composition.execute_install( install, state.selection.selection, expected_policy_digest=policy.policy_digest, ) assert report.outcome == "applied" assert report.settled assert agent_load_calls == [install.action_id] assert (agent_root / "reviewer.md").read_text(encoding="utf-8") == body def test_runtime_package_does_not_export_raw_install_driver_construction() -> None: import ctx.runtime as runtime assert not hasattr(runtime, "InstallDriverRegistry") assert not hasattr(runtime, "prepare_install_execution") @pytest.mark.skipif(os.name == "nt", reason="built-in skill CAS is POSIX-only") def test_changed_skill_target_fails_before_composition_creates_authoritative_state( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) skill_root = tmp_path / "ctx-private" / "skills" skill_root.mkdir(parents=True, mode=0o700) skill_root.chmod(0o700) class _BodySource: def load( self, _request: InstallDriverRequest, _material: MaterialIdentity, ) -> str: raise AssertionError("body source must not be reached during composition") runtime = SkillCasRuntimeConfig( skill_store_root=skill_root, body_source=_BodySource(), installer_id="ctx-skill-installer-v1", host_identity_digest=_digest("changed-composition-host"), ) original = skill_root.with_name("skills-original") skill_root.rename(original) skill_root.mkdir(mode=0o700) skill_root.chmod(0o700) with pytest.raises(RuntimeError, match="root changed"): _open_composition(tmp_path, graph, skill_cas_runtime=runtime) assert not (tmp_path / "journal.sqlite3").exists() assert not (tmp_path / "benefit-audit.sqlite3").exists() @pytest.mark.skipif(os.name == "nt", reason="agent-file actuator is POSIX-only") def test_changed_agent_target_fails_before_composition_creates_authoritative_state( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) agent_root = tmp_path / "ctx-private" / "inactive-agents" agent_root.mkdir(parents=True, mode=0o700) agent_root.chmod(0o700) class _BodySource: def load( self, _request: InstallDriverRequest, _material: MaterialIdentity, ) -> str: raise AssertionError("body source must not be reached during composition") runtime = AgentFileRuntimeConfig( inactive_agent_root=agent_root, body_source=_BodySource(), installer_id="ctx-agent-installer-v1", host_identity_digest=_digest("changed-agent-composition-host"), ) original = agent_root.with_name("inactive-agents-original") agent_root.rename(original) agent_root.mkdir(mode=0o700) agent_root.chmod(0o700) with pytest.raises(RuntimeError, match="root changed"): _open_composition(tmp_path, graph, agent_file_runtime=runtime) assert not (tmp_path / "journal.sqlite3").exists() assert not (tmp_path / "benefit-audit.sqlite3").exists() def test_composition_wires_host_authenticated_interactive_decision_guard( tmp_path: Path, ) -> None: graph = _graph_artifact(tmp_path) install_port, _descriptor = _install_port() policy = InstallConsentPolicy.safe_default() reservations: list[InteractiveInstallDecisionReservation] = [] @contextmanager def decision_guard( reservation: InteractiveInstallDecisionReservation, ) -> Iterator[None]: reservations.append(reservation) yield with _open_composition( tmp_path, graph, install_bundle_port=install_port, interactive_install_decision_guard=decision_guard, trusted_utc_now=_trusted_now, ) as composition: capability = _plan(composition)[0] consent = composition.process( _event( composition, "ReassessmentRequested", 2, "event-interactive-desired", payload={ "owner_id": "runtime-owner-1", "policy_snapshot_digest": policy.policy_digest, "desired_capabilities": [ { "capability_id": capability["capability_id"], "source_digest": capability["catalog_entry_digest"], "lease_id": "lease-1", "kind": capability["kind"], "actionability": capability["actionability"], "install_descriptor_digest": capability["install_descriptor_digest"], "install_plan_digest": capability["install_plan_digest"], } ], }, ) ) request = consent.actions[0] granted = composition.process( _event( composition, "UserDecision", 3, "event-interactive-grant", payload={ "consent_id": request.consent_id or "", "decision": "granted", "decision_basis": "interactive", "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" ], }, ) ) assert [action.kind for action in granted.actions] == ["InstallCapability"] assert len(reservations) == 1 assert reservations[0].decision == "granted" assert reservations[0].requested_action_id == granted.actions[0].action_id def test_composition_rejects_changed_descriptor_during_auto_grant(tmp_path: Path) -> None: graph = _graph_artifact(tmp_path) install_port, bundle = _install_port() policy_root = tmp_path / "install-policy" policy = InstallConsentPolicy(skill_mode="preapproved-auto") persist_install_policy(policy, policy_root) with _open_composition( tmp_path, graph, install_bundle_port=install_port, policy_store_root=policy_root, trusted_utc_now=_trusted_now, ) as composition: capability = _plan(composition)[0] consent = composition.process( _event( composition, "ReassessmentRequested", 2, "event-desired", payload={ "owner_id": "runtime-owner-1", "policy_snapshot_digest": policy.policy_digest, "desired_capabilities": [ { "capability_id": capability["capability_id"], "source_digest": capability["catalog_entry_digest"], "lease_id": "lease-1", "kind": capability["kind"], "actionability": capability["actionability"], "install_descriptor_digest": capability["install_descriptor_digest"], "install_plan_digest": capability["install_plan_digest"], } ], }, ) ) request = consent.actions[0] install_port.bundles[bundle.descriptor.capability_id] = None with pytest.raises(CtxEngineError, match="authority lookup failed"): composition.process( _event( composition, "UserDecision", 3, "event-auto-grant", payload={ "consent_id": request.consent_id or "", "decision": "granted", "decision_basis": "preapproved-policy", "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" ], }, ) ) def test_composition_closes_safely_and_cannot_be_reentered(tmp_path: Path) -> None: graph = _graph_artifact(tmp_path) composition = _open_composition(tmp_path, graph) with composition: assert composition.closed is False assert not hasattr(composition, "engine") assert composition.closed is True composition.close() with pytest.raises(RuntimeError, match="closed"): composition.__enter__() with pytest.raises(RuntimeError, match="closed"): composition.process( _event( composition, "SessionStarted", 0, "event-after-close", payload={"host_level": "managing"}, ) ) with _open_composition( tmp_path, graph, ) as reopened: assert reopened.snapshot(_scope()).revision == 0 def test_composition_rejects_invalid_artifact_and_port(tmp_path: Path) -> None: graph = _graph_artifact(tmp_path) with pytest.raises(CandidateSourceUnavailable, match="unavailable"): _open_composition( tmp_path, graph, graph_artifact_sha256="f" * 64, journal_name="wrong-digest.sqlite3", audit_name="wrong-digest-audit.sqlite3", ) class _InvalidInstallPort: installation_snapshot_digest = "not-a-digest" def describe_bundle(self, _capability_id: str, _kind: str) -> None: return None with pytest.raises(TypeError, match="install bundle contract"): open_engine_composition( graph_artifact_path=graph, graph_artifact_sha256=_artifact_digest(graph), journal_path=tmp_path / "invalid-port.sqlite3", observation_normalizer=_normalizer, benefit_facts_port=_AuthenticatedFacts(), net_benefit_policy=_policy(), catalog_namespace_digest=CATALOG_NAMESPACE_DIGEST, benefit_audit_path=tmp_path / "invalid-port-audit.sqlite3", install_bundle_port=_InvalidInstallPort(), # type: ignore[arg-type] ) def test_composition_cleans_up_source_when_later_validation_fails(tmp_path: Path) -> None: graph = _graph_artifact(tmp_path) with pytest.raises(PlannerValidationError, match="planner_version"): _open_composition( tmp_path, graph, planner_version="not a safe planner version", ) assert not tuple(tmp_path.glob(".ctx-indexed-snapshot-*")) def test_composition_preserves_construction_error_when_cleanup_also_fails( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: graph = _graph_artifact(tmp_path) def fail_close(_source: IndexedGraphCandidateSource) -> None: raise OSError("injected cleanup failure") monkeypatch.setattr(IndexedGraphCandidateSource, "close", fail_close) with pytest.raises(PlannerValidationError, match="planner_version") as captured: _open_composition( tmp_path, graph, planner_version="not a safe planner version", ) assert captured.value.__notes__ == ["CTX candidate-source cleanup also failed with OSError"] def test_composition_preserves_body_error_when_context_cleanup_also_fails( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: graph = _graph_artifact(tmp_path) composition = _open_composition(tmp_path, graph) original_close = IndexedGraphCandidateSource.close def fail_close(_source: IndexedGraphCandidateSource) -> None: raise OSError("injected cleanup failure") monkeypatch.setattr(IndexedGraphCandidateSource, "close", fail_close) with pytest.raises(RuntimeError, match="body failure") as captured: with composition: raise RuntimeError("body failure") assert captured.value.__notes__ == ["CTX candidate-source cleanup also failed with OSError"] assert composition.closed is False monkeypatch.setattr(IndexedGraphCandidateSource, "close", original_close) composition.close()