from __future__ import annotations import dataclasses import hashlib from pathlib import Path import pytest from ctx.engine.lineage import CatalogCapabilityIdentity from ctx.engine.planner import CapabilityCandidate from ctx.engine.planning_v3 import ( BenefitAuditReference, CapabilityBenefitProjection, CapabilityPlanSelectionV3, ManualPlanningAuthority, ) from ctx.engine.protocol import HostAction, ScopeRef, Transition from ctx.engine.state import CommittedPlanV3, PlanCapabilityV3 from ctx.runtime.production_catalog import ( RELEASE_QUERY_CATALOG_MODE, RELEASE_QUERY_CATALOG_ROOT_SHA256, RELEASE_QUERY_CATALOG_SEQUENCE, ) from ctx.runtime.query_decision import ( CapabilitySelection, CommittedQueryDecision, QueryDecisionFailure, QueryDecisionValidationError, QueryHostDescriptor, _capability_selections_from_committed_transition, _commit_query_decision, _receipt_digest, accept_query_decision, prepare_query_decision, render_query_decision_context, ) def _digest(value: str) -> str: return hashlib.sha256(value.encode("utf-8")).hexdigest() def _selection() -> CapabilitySelection: return CapabilitySelection( capability_id="skill:python-tdd", kind="skill", name="python-tdd", actionability="load", normalized_score_ppm=900_000, source_digest=_digest("catalog-entry"), matching_signals=("python", "testing"), reason_codes=("signal-match",), ) def _reviewed_decision(host: QueryHostDescriptor) -> CommittedQueryDecision: plan, transition = _ready_plan_and_transition(host) return _commit_query_decision( host=host, plan=plan, transition=transition, journal_revision=2, journal_record_digest=_digest("journal-record"), release_root_digest=_digest("reviewed-release-root"), release_sequence=2, catalog_mode="reviewed", work_signature_digest=_digest("reviewed-work-signature"), host_invocation_digest=_digest("reviewed-host-invocation"), ) def test_host_descriptors_are_closed_and_bind_distinct_host_provenance() -> None: hosts = ( QueryHostDescriptor.ctx_run(), QueryHostDescriptor.codex(), QueryHostDescriptor.claude_code(), ) assert tuple(host.host_context_id for host in hosts) == ( "ctx-run", "codex", "claude-code", ) assert len({host.host_descriptor_digest for host in hosts}) == 3 with pytest.raises(TypeError): class DerivedHost(QueryHostDescriptor): pass def test_committed_decision_stores_only_safe_selections_and_derives_context() -> None: host = QueryHostDescriptor.codex() decision = _reviewed_decision(host) stored_fields = {field.name for field in dataclasses.fields(decision)} assert "recommendation_context" not in stored_fields assert "presentation_digest" in stored_fields assert decision.status == "presented" assert decision.recommendation_count == 1 assert decision.failure_code is None assert decision.recommendation_context == render_query_decision_context(decision, host=host) assert decision.recommendation_context == ( "CTX recommendation bundle (committed, advisory only):\n" "1. kind=agent | name=reviewer | id=agent:reviewer | " "actionability=manual | score_ppm=600000\n" "Use only capabilities relevant to the current task. " "Do not install, load, or activate anything without user approval." ) assert "matching_signals" not in decision.recommendation_context assert "catalog_entry_digest" not in decision.recommendation_context assert "_receipt_seal" not in repr(decision) def test_public_constructor_cannot_fabricate_a_committed_receipt() -> None: host = QueryHostDescriptor.codex() with pytest.raises(QueryDecisionValidationError, match="closed factory"): CommittedQueryDecision( host_context_id=host.host_context_id, host_descriptor_digest=host.host_descriptor_digest, capabilities=(_selection(),), plan_digest=_digest("plan"), catalog_snapshot_digest=_digest("catalog-snapshot"), journal_revision=2, journal_record_digest=_digest("journal-record"), release_root_digest=_digest("reviewed-release-root"), release_sequence=2, catalog_mode="reviewed", abstention_code=None, presentation_action_id="action-present-1", presentation_action_content_digest=_digest("present-action"), work_signature_digest=_digest("work-signature"), host_invocation_digest=_digest("host-invocation"), presentation_digest=_digest("invented-presentation"), receipt_digest=_digest("invented-receipt"), _receipt_seal=object(), ) def _ready_plan_and_transition( host: QueryHostDescriptor, ) -> tuple[CommittedPlanV3, Transition]: scope = ScopeRef( tenant_id="local", workspace_id="workspace-1", repository_id="repository-1", session_id="session-1", exposure_id="exposure-1", host_context_id=host.host_context_id, ) presentation = CapabilityCandidate( capability_id="agent:reviewer", kind="agent", name="reviewer", source_digest=_digest("catalog-entry:agent:reviewer"), normalized_score_ppm=600_000, matching_signals=("review",), reason_codes=("signal-match",), actionability="manual", ) selection = CapabilityPlanSelectionV3( presentation=presentation, catalog_identity=CatalogCapabilityIdentity.create( capability_id=presentation.capability_id, kind=presentation.kind, catalog_namespace_digest=_digest("catalog-namespace"), ), benefit=CapabilityBenefitProjection( tier="advisory", individual_net_benefit_u=600_000, marginal_net_benefit_u=600_000, ), authority=ManualPlanningAuthority(), ) plan = CommittedPlanV3( plan_id="plan-1", catalog_snapshot_id=_digest("catalog-snapshot"), decision_digest=_digest("decision"), status="ready", abstention_code=None, benefit_audit=BenefitAuditReference( result_schema_id="ctx.benefit-result-v1", result_digest=_digest("result"), policy_schema_id="ctx.benefit-policy-v1", policy_digest=_digest("policy"), selection_algorithm_id="ctx.benefit-selection-v1", calibration_digest=_digest("calibration"), requested_limit=5, candidate_pool_count=1, search_evaluation_count=1, ), capabilities=(PlanCapabilityV3(selection=selection),), ) transition = Transition( event_id="event-intent-1", scope=scope, from_revision=1, to_revision=2, actions=( HostAction( action_id="action-present-1", kind="PresentBundle", scope=scope, precondition_revision=2, payload={ "plan_digest": plan.decision_digest, "capabilities": [selection.to_mapping()], }, ), ), ) return plan, transition def _current_abstention(host: QueryHostDescriptor) -> CommittedQueryDecision: scope = ScopeRef( tenant_id="local", workspace_id="workspace-1", repository_id="repository-1", session_id="session-1", exposure_id="exposure-1", host_context_id=host.host_context_id, ) plan = CommittedPlanV3( plan_id="plan-1", catalog_snapshot_id=_digest("catalog-snapshot"), decision_digest=_digest("abstained-decision"), status="abstained", abstention_code="no-feasible-capability", benefit_audit=BenefitAuditReference( result_schema_id="ctx.benefit-result-v1", result_digest=_digest("result"), policy_schema_id="ctx.benefit-policy-v1", policy_digest=_digest("policy"), selection_algorithm_id="ctx.benefit-selection-v1", calibration_digest=_digest("calibration"), requested_limit=5, candidate_pool_count=0, search_evaluation_count=0, ), capabilities=(), ) transition = Transition( event_id="event-intent-1", scope=scope, from_revision=1, to_revision=2, ) return _commit_query_decision( host=host, plan=plan, transition=transition, journal_revision=2, journal_record_digest=_digest("journal-record"), release_root_digest=RELEASE_QUERY_CATALOG_ROOT_SHA256, release_sequence=RELEASE_QUERY_CATALOG_SEQUENCE, catalog_mode=RELEASE_QUERY_CATALOG_MODE, work_signature_digest=_digest("current-work-signature"), host_invocation_digest=_digest("current-host-invocation"), ) @pytest.mark.parametrize("mutation", ["plan-digest", "full-v3-row"]) def test_commit_projection_rejects_substitution_between_transition_and_plan( mutation: str, ) -> None: plan, transition = _ready_plan_and_transition(QueryHostDescriptor.codex()) action = transition.actions[0] payload = { "plan_digest": action.payload["plan_digest"], "capabilities": [dict(action.payload["capabilities"][0])], } if mutation == "plan-digest": payload["plan_digest"] = _digest("substituted-plan") else: row = payload["capabilities"][0] assert isinstance(row, dict) row["normalized_score_ppm"] = 599_999 substituted = dataclasses.replace( transition, actions=(dataclasses.replace(action, payload=payload),), ) with pytest.raises(QueryDecisionValidationError, match="committed plan"): _capability_selections_from_committed_transition(substituted, plan) def test_commit_projection_rejects_an_extra_non_presentation_action() -> None: host = QueryHostDescriptor.codex() plan, transition = _ready_plan_and_transition(host) substituted = dataclasses.replace( transition, actions=( *transition.actions, HostAction( action_id="action-unexpected-notify", kind="Notify", scope=transition.scope, precondition_revision=2, payload={"message": "unexpected"}, ), ), ) with pytest.raises(QueryDecisionValidationError, match="committed plan"): _capability_selections_from_committed_transition(substituted, plan) def test_acceptance_copies_exact_values_and_rejects_false_host_provenance() -> None: codex = QueryHostDescriptor.codex() decision = _reviewed_decision(codex) accepted = accept_query_decision(decision, host=codex) assert accepted == decision assert accepted is not decision assert accepted.capabilities[0] is not decision.capabilities[0] with pytest.raises(QueryDecisionValidationError, match="host provenance"): accept_query_decision(decision, host=QueryHostDescriptor.claude_code()) with pytest.raises(TypeError, match="sealed"): class DerivedDecision(CommittedQueryDecision): pass def test_acceptance_rejects_coherent_host_rebranding_and_journal_substitution() -> None: rebranded = _reviewed_decision(QueryHostDescriptor.claude_code()) codex = QueryHostDescriptor.codex() object.__setattr__(rebranded, "host_context_id", codex.host_context_id) object.__setattr__( rebranded, "host_descriptor_digest", codex.host_descriptor_digest, ) object.__setattr__( rebranded, "receipt_digest", _receipt_digest( host_context_id=rebranded.host_context_id, host_descriptor_digest=rebranded.host_descriptor_digest, journal_revision=rebranded.journal_revision, journal_record_digest=rebranded.journal_record_digest, presentation_digest=rebranded.presentation_digest, presentation_action_id=rebranded.presentation_action_id, presentation_action_content_digest=(rebranded.presentation_action_content_digest), work_signature_digest=rebranded.work_signature_digest, host_invocation_digest=rebranded.host_invocation_digest, ), ) substituted_journal = _reviewed_decision(QueryHostDescriptor.claude_code()) object.__setattr__( substituted_journal, "journal_record_digest", _digest("substituted-journal-record"), ) object.__setattr__( substituted_journal, "receipt_digest", _receipt_digest( host_context_id=substituted_journal.host_context_id, host_descriptor_digest=substituted_journal.host_descriptor_digest, journal_revision=substituted_journal.journal_revision, journal_record_digest=substituted_journal.journal_record_digest, presentation_digest=substituted_journal.presentation_digest, presentation_action_id=substituted_journal.presentation_action_id, presentation_action_content_digest=( substituted_journal.presentation_action_content_digest ), work_signature_digest=substituted_journal.work_signature_digest, host_invocation_digest=substituted_journal.host_invocation_digest, ), ) with pytest.raises(QueryDecisionValidationError): accept_query_decision(rebranded, host=codex) with pytest.raises(QueryDecisionValidationError): accept_query_decision( substituted_journal, host=QueryHostDescriptor.claude_code(), ) def test_acceptance_normalizes_hostile_exact_field_values() -> None: class HostileHostId(str): def __hash__(self) -> int: raise RuntimeError("secret=/private/repository/path") decision = _reviewed_decision(QueryHostDescriptor.codex()) object.__setattr__(decision, "host_context_id", HostileHostId("codex")) with pytest.raises(QueryDecisionValidationError) as raised: accept_query_decision(decision, host=QueryHostDescriptor.codex()) assert "secret" not in str(raised.value) assert "/private" not in str(raised.value) def test_current_reviewed_release_can_commit_an_exact_presented_bundle() -> None: host = QueryHostDescriptor.ctx_run() plan, transition = _ready_plan_and_transition(host) decision = _commit_query_decision( host=host, plan=plan, transition=transition, journal_revision=2, journal_record_digest=_digest("journal-record"), release_root_digest=RELEASE_QUERY_CATALOG_ROOT_SHA256, release_sequence=RELEASE_QUERY_CATALOG_SEQUENCE, catalog_mode=RELEASE_QUERY_CATALOG_MODE, work_signature_digest=_digest("current-work-signature"), host_invocation_digest=_digest("current-host-invocation"), ) assert decision.status == "presented" assert tuple(item.capability_id for item in decision.capabilities) == ("agent:reviewer",) assert decision.journal_revision == 2 @pytest.mark.parametrize( ("field", "value"), [ ("host_descriptor_digest", _digest("substituted-host")), ("release_sequence", RELEASE_QUERY_CATALOG_SEQUENCE + 1), ("catalog_mode", "abstention-only"), ], ) def test_acceptance_rejects_substituted_current_release_or_host_fields( field: str, value: object, ) -> None: host = QueryHostDescriptor.ctx_run() decision = _current_abstention(host) unsafe = object.__new__(CommittedQueryDecision) for data_field in dataclasses.fields(decision): object.__setattr__( unsafe, data_field.name, value if data_field.name == field else getattr(decision, data_field.name), ) with pytest.raises(QueryDecisionValidationError): accept_query_decision(unsafe, host=host) def test_failure_is_separate_bounded_and_contains_no_decision_receipt() -> None: failure = QueryDecisionFailure(failure_code="catalog-open-failed") assert failure.status == "failed" assert failure.recommendation_context is None assert failure.recommendation_count == 0 assert render_query_decision_context(failure, host=QueryHostDescriptor.codex()) is None with pytest.raises(QueryDecisionValidationError): QueryDecisionFailure(failure_code="failure /private/repository token=secret") @pytest.mark.parametrize( "host", [ QueryHostDescriptor.ctx_run(), QueryHostDescriptor.codex(), QueryHostDescriptor.claude_code(), ], ids=lambda host: host.host_context_id, ) def test_production_factory_commits_the_same_closed_abstention_for_each_host( host: QueryHostDescriptor, tmp_path: Path, ) -> None: host_root = tmp_path / host.host_context_id task = "Repair token=do-not-journal at /private/repository/path" result = prepare_query_decision( host=host, task=task, language="Python", session_id=f"session-{host.host_context_id}", workspace=tmp_path, journal_path=host_root / "session.engine.sqlite3", benefit_audit_path=host_root / "session.benefit.sqlite3", host_invocation_digest=_digest(f"host-invocation:{host.host_context_id}"), ) assert isinstance(result, CommittedQueryDecision) assert result.status == "abstained" assert result.capabilities == () assert result.abstention_code is not None assert result.host_context_id == host.host_context_id assert result.host_descriptor_digest == host.host_descriptor_digest assert result.journal_revision == 2 assert result.release_root_digest == RELEASE_QUERY_CATALOG_ROOT_SHA256 assert result.release_sequence == RELEASE_QUERY_CATALOG_SEQUENCE assert result.catalog_mode == RELEASE_QUERY_CATALOG_MODE journal_bytes = (host_root / "session.engine.sqlite3").read_bytes() assert task.encode() not in journal_bytes assert b"do-not-journal" not in journal_bytes assert str(tmp_path).encode() not in journal_bytes def test_host_brand_does_not_perturb_the_semantic_plan_or_presentation( tmp_path: Path, ) -> None: results: list[CommittedQueryDecision] = [] for host in ( QueryHostDescriptor.ctx_run(), QueryHostDescriptor.codex(), QueryHostDescriptor.claude_code(), ): host_root = tmp_path / host.host_context_id result = prepare_query_decision( host=host, task="Review the Python implementation", language="Python", session_id="same-session", workspace=tmp_path, journal_path=host_root / "session.engine.sqlite3", benefit_audit_path=host_root / "session.benefit.sqlite3", host_invocation_digest=_digest("same-host-invocation"), ) assert isinstance(result, CommittedQueryDecision) results.append(result) assert len({result.plan_digest for result in results}) == 1 assert len({result.catalog_snapshot_digest for result in results}) == 1 assert len({result.presentation_digest for result in results}) == 1 assert len({result.receipt_digest for result in results}) == 3 assert len({result.host_descriptor_digest for result in results}) == 3 def test_host_receipt_binds_exact_action_work_and_invocation_without_changing_semantics() -> None: host = QueryHostDescriptor.codex() plan, transition = _ready_plan_and_transition(host) first = _commit_query_decision( host=host, plan=plan, transition=transition, journal_revision=2, journal_record_digest=_digest("journal-record"), release_root_digest=_digest("reviewed-release-root"), release_sequence=2, catalog_mode="reviewed", work_signature_digest=_digest("work-a"), host_invocation_digest=_digest("invocation-a"), ) substituted_action = dataclasses.replace( transition, actions=(dataclasses.replace(transition.actions[0], action_id="action-present-2"),), ) second = _commit_query_decision( host=host, plan=plan, transition=substituted_action, journal_revision=2, journal_record_digest=_digest("journal-record"), release_root_digest=_digest("reviewed-release-root"), release_sequence=2, catalog_mode="reviewed", work_signature_digest=_digest("work-b"), host_invocation_digest=_digest("invocation-b"), ) assert first.presentation_digest == second.presentation_digest assert first.presentation_action_id == "action-present-1" assert second.presentation_action_id == "action-present-2" assert first.presentation_action_content_digest == transition.actions[0].content_digest assert second.presentation_action_content_digest == substituted_action.actions[0].content_digest assert first.work_signature_digest == _digest("work-a") assert second.work_signature_digest == _digest("work-b") assert first.host_invocation_digest == _digest("invocation-a") assert second.host_invocation_digest == _digest("invocation-b") assert first.receipt_digest != second.receipt_digest @pytest.mark.parametrize( "field", [ "presentation_action_id", "presentation_action_content_digest", "work_signature_digest", "host_invocation_digest", ], ) def test_acceptance_rejects_coherently_rehashed_host_receipt_substitution(field: str) -> None: host = QueryHostDescriptor.codex() decision = _reviewed_decision(host) replacement: str | None = ( "substituted-present-action" if field == "presentation_action_id" else _digest(f"substituted:{field}") ) object.__setattr__(decision, field, replacement) object.__setattr__( decision, "receipt_digest", _receipt_digest( host_context_id=decision.host_context_id, host_descriptor_digest=decision.host_descriptor_digest, journal_revision=decision.journal_revision, journal_record_digest=decision.journal_record_digest, presentation_digest=decision.presentation_digest, presentation_action_id=decision.presentation_action_id, presentation_action_content_digest=decision.presentation_action_content_digest, work_signature_digest=decision.work_signature_digest, host_invocation_digest=decision.host_invocation_digest, ), ) with pytest.raises(QueryDecisionValidationError): accept_query_decision(decision, host=host)