| from __future__ import annotations |
|
|
| import ast |
| import copy |
| import hashlib |
| import inspect |
| from dataclasses import replace |
|
|
| import pytest |
|
|
| from ctx.adapters import recommendation_presentation |
| from ctx.adapters.claude_code import engine_hook |
| from ctx.adapters.claude_code.engine_hook import render_recommendation_hook |
| from ctx.adapters.codex import engine_adapter |
| from ctx.adapters.codex.engine_adapter import render_recommendation_context |
| from ctx.adapters.recommendation_presentation import ( |
| RecommendationPresentationError, |
| render_present_bundle_context, |
| ) |
| from ctx.engine.content import AuthorizedMaterial, MaterialDescriptor, MaterialIdentity |
| from ctx.engine.installation import InstallPlanDescriptor |
| from ctx.engine.lineage import CatalogCapabilityIdentity |
| from ctx.engine.planner import CapabilityCandidate |
| from ctx.engine.planning_v3 import ( |
| CapabilityBenefitProjection, |
| CapabilityPlanSelectionV3, |
| InstallPlanningAuthority, |
| LoadPlanningAuthority, |
| ManualPlanningAuthority, |
| PlanningAuthority, |
| ) |
| from ctx.engine.protocol import HostAction, ScopeRef, Transition |
|
|
|
|
| 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-1", |
| ) |
|
|
|
|
| def _row( |
| capability_id: str, |
| kind: str, |
| name: str, |
| digest_character: str, |
| score: int, |
| actionability: str, |
| signals: list[str], |
| reasons: list[str], |
| ) -> dict[str, object]: |
| return { |
| "actionability": actionability, |
| "capability_id": capability_id, |
| "catalog_entry_digest": digest_character * 64, |
| "kind": kind, |
| "matching_signals": signals, |
| "name": name, |
| "normalized_score_ppm": score, |
| "reason_codes": reasons, |
| } |
|
|
|
|
| def _transition() -> Transition: |
| scope = _scope() |
| action = HostAction( |
| action_id="action-present-1", |
| kind="PresentBundle", |
| scope=scope, |
| precondition_revision=2, |
| payload={ |
| "plan_digest": "f" * 64, |
| "capabilities": [ |
| _row( |
| "mcp-server:python-docs", |
| "mcp-server", |
| "python-docs", |
| "a", |
| 750_000, |
| "install", |
| ["docs", "python"], |
| ["signal-match"], |
| ), |
| _row( |
| "skill:python-tdd", |
| "skill", |
| "python-tdd", |
| "b", |
| 950_000, |
| "load", |
| ["python", "testing"], |
| ["signal-match", "workflow-match"], |
| ), |
| _row( |
| "harness:codex-python", |
| "harness", |
| "codex-python", |
| "c", |
| 850_000, |
| "manual", |
| ["python"], |
| ["host-match"], |
| ), |
| _row( |
| "agent:python-reviewer", |
| "agent", |
| "python-reviewer", |
| "d", |
| 900_000, |
| "load", |
| ["python", "review"], |
| ["signal-match"], |
| ), |
| _row( |
| "skill:security-review", |
| "skill", |
| "security-review", |
| "e", |
| 800_000, |
| "manual", |
| ["review", "security"], |
| ["policy-match"], |
| ), |
| ], |
| }, |
| ) |
| return Transition( |
| event_id="event-observation-1", |
| scope=scope, |
| from_revision=1, |
| to_revision=2, |
| actions=(action,), |
| ) |
|
|
|
|
| EXPECTED_CONTEXT = """CTX recommendation bundle (committed, advisory only): |
| 1. kind=mcp-server | name=python-docs | id=mcp-server:python-docs | actionability=install | score_ppm=750000 |
| 2. kind=skill | name=python-tdd | id=skill:python-tdd | actionability=load | score_ppm=950000 |
| 3. kind=harness | name=codex-python | id=harness:codex-python | actionability=manual | score_ppm=850000 |
| 4. kind=agent | name=python-reviewer | id=agent:python-reviewer | actionability=load | score_ppm=900000 |
| 5. kind=skill | name=security-review | id=skill:security-review | actionability=manual | score_ppm=800000 |
| Use only capabilities relevant to the current task. Do not install, load, or activate anything without user approval.""" |
|
|
|
|
| def _digest(value: str) -> str: |
| return hashlib.sha256(value.encode()).hexdigest() |
|
|
|
|
| def _v3_row( |
| capability_id: str, |
| *, |
| actionability: str, |
| score: int, |
| ) -> dict[str, object]: |
| kind, name = capability_id.split(":", 1) |
| catalog_identity = CatalogCapabilityIdentity.create( |
| capability_id=capability_id, |
| kind=kind, |
| catalog_namespace_digest=_digest("renderer-catalog"), |
| ) |
| install_descriptor_digest = None |
| install_plan_digest = None |
| authority: PlanningAuthority |
| if actionability == "load": |
| material = MaterialIdentity.create( |
| capability_id=capability_id, |
| kind=kind, |
| content_sha256=_digest(f"content:{capability_id}"), |
| content_bytes=32, |
| ) |
| material_descriptor = 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("renderer-material-snapshot"), |
| material_identity_digest=material.identity_digest, |
| ) |
| authority = LoadPlanningAuthority( |
| material=AuthorizedMaterial.from_catalog( |
| catalog_identity_digest=catalog_identity.identity_digest, |
| descriptor=material_descriptor, |
| ) |
| ) |
| tier = "executable" |
| elif actionability == "install": |
| result_material = MaterialIdentity.create( |
| capability_id=capability_id, |
| kind=kind, |
| content_sha256=_digest(f"installed-content:{capability_id}"), |
| content_bytes=48, |
| ) |
| install_descriptor = InstallPlanDescriptor.create( |
| capability_id=capability_id, |
| kind=kind, |
| installer_id="ctx-installer", |
| plan_digest=_digest(f"install-plan:{capability_id}"), |
| provenance_digest=_digest("renderer-install-snapshot"), |
| result_material_identity_digest=result_material.identity_digest, |
| ) |
| install_descriptor_digest = install_descriptor.descriptor_digest |
| install_plan_digest = install_descriptor.plan_digest |
| authority = InstallPlanningAuthority( |
| descriptor=install_descriptor, |
| result_material=result_material, |
| ) |
| tier = "executable" |
| else: |
| authority = ManualPlanningAuthority() |
| tier = "advisory" |
| presentation = CapabilityCandidate( |
| capability_id=capability_id, |
| kind=kind, |
| name=name, |
| source_digest=_digest(f"catalog-entry:{capability_id}"), |
| normalized_score_ppm=score, |
| matching_signals=("python",), |
| reason_codes=("signal-match",), |
| actionability=actionability, |
| install_descriptor_digest=install_descriptor_digest, |
| install_plan_digest=install_plan_digest, |
| ) |
| return CapabilityPlanSelectionV3( |
| presentation=presentation, |
| catalog_identity=catalog_identity, |
| benefit=CapabilityBenefitProjection( |
| tier=tier, |
| individual_net_benefit_u=score, |
| marginal_net_benefit_u=max(score, 1), |
| ), |
| authority=authority, |
| ).to_mapping() |
|
|
|
|
| def _v3_transition(rows: list[dict[str, object]]) -> Transition: |
| scope = _scope() |
| return Transition( |
| event_id="event-v3-observation-1", |
| scope=scope, |
| from_revision=1, |
| to_revision=2, |
| actions=( |
| HostAction( |
| action_id="action-v3-present-1", |
| kind="PresentBundle", |
| scope=scope, |
| precondition_revision=2, |
| payload={"plan_digest": _digest("v3-plan"), "capabilities": rows}, |
| ), |
| ), |
| ) |
|
|
|
|
| EXPECTED_V3_CONTEXT = """CTX recommendation bundle (committed, advisory only): |
| 1. kind=agent | name=reviewer | id=agent:reviewer | actionability=manual | score_ppm=600000 |
| 2. kind=skill | name=python-tdd | id=skill:python-tdd | actionability=load | score_ppm=900000 |
| 3. kind=mcp-server | name=python-docs | id=mcp-server:python-docs | actionability=install | score_ppm=700000 |
| Use only capabilities relevant to the current task. Do not install, load, or activate anything without user approval.""" |
|
|
|
|
| def test_codex_and_claude_render_the_identical_ordered_engine_bundle() -> None: |
| transition = _transition() |
|
|
| codex_context = render_recommendation_context(transition) |
| claude_envelope = render_recommendation_hook(transition) |
|
|
| assert codex_context == EXPECTED_CONTEXT |
| assert claude_envelope == { |
| "hookSpecificOutput": { |
| "hookEventName": "PostToolUse", |
| "additionalContext": EXPECTED_CONTEXT, |
| } |
| } |
|
|
|
|
| def test_renderers_accept_exact_install_bound_v2_rows_without_changing_order() -> None: |
| transition = _transition() |
| bundle = transition.actions[0] |
| rows = [] |
| for raw in bundle.payload["capabilities"]: |
| row = dict(raw) |
| row["install_descriptor_digest"] = "8" * 64 if row["actionability"] == "install" else None |
| row["install_plan_digest"] = "9" * 64 if row["actionability"] == "install" else None |
| rows.append(row) |
| v2 = replace( |
| transition, |
| actions=( |
| replace( |
| bundle, |
| payload={ |
| "plan_digest": bundle.payload["plan_digest"], |
| "capabilities": rows, |
| }, |
| ), |
| ), |
| ) |
|
|
| assert render_recommendation_context(v2) == EXPECTED_CONTEXT |
| assert render_recommendation_hook(v2) == { |
| "hookSpecificOutput": { |
| "hookEventName": "PostToolUse", |
| "additionalContext": EXPECTED_CONTEXT, |
| } |
| } |
|
|
|
|
| def test_shared_renderer_accepts_complete_v3_rows_without_reranking_or_leaking_authority() -> None: |
| transition = _v3_transition( |
| [ |
| _v3_row("agent:reviewer", actionability="manual", score=600_000), |
| _v3_row("skill:python-tdd", actionability="load", score=900_000), |
| _v3_row("mcp-server:python-docs", actionability="install", score=700_000), |
| ] |
| ) |
|
|
| context = render_present_bundle_context(transition) |
|
|
| assert context == EXPECTED_V3_CONTEXT |
| assert "catalog_identity" not in context |
| assert "benefit" not in context |
| assert "authority" not in context |
| assert "install_descriptor_digest" not in context |
| assert "install_plan_digest" not in context |
| assert render_recommendation_context(transition) == EXPECTED_V3_CONTEXT |
| assert render_recommendation_hook(transition) == { |
| "hookSpecificOutput": { |
| "hookEventName": "PostToolUse", |
| "additionalContext": EXPECTED_V3_CONTEXT, |
| } |
| } |
|
|
|
|
| @pytest.mark.parametrize( |
| "mutation", |
| [ |
| "unknown-row-field", |
| "unknown-catalog-field", |
| "unknown-benefit-field", |
| "unknown-authority-field", |
| "catalog-identity-substitution", |
| "benefit-tier-substitution", |
| ], |
| ) |
| def test_shared_renderer_rejects_mutated_v3_identity_benefit_and_authority( |
| mutation: str, |
| ) -> None: |
| row = copy.deepcopy(_v3_row("skill:python-tdd", actionability="load", score=900_000)) |
| if mutation == "unknown-row-field": |
| row["unknown"] = True |
| elif mutation == "unknown-catalog-field": |
| catalog_identity = row["catalog_identity"] |
| assert isinstance(catalog_identity, dict) |
| catalog_identity["unknown"] = True |
| elif mutation == "unknown-benefit-field": |
| benefit = row["benefit"] |
| assert isinstance(benefit, dict) |
| benefit["unknown"] = True |
| elif mutation == "unknown-authority-field": |
| authority = row["authority"] |
| assert isinstance(authority, dict) |
| authority["unknown"] = True |
| elif mutation == "catalog-identity-substitution": |
| foreign = _v3_row("skill:foreign", actionability="load", score=900_000) |
| row["catalog_identity"] = foreign["catalog_identity"] |
| else: |
| benefit = row["benefit"] |
| assert isinstance(benefit, dict) |
| benefit["tier"] = "advisory" |
| transition = _v3_transition([row]) |
|
|
| with pytest.raises(RecommendationPresentationError, match="invalid PresentBundle"): |
| render_present_bundle_context(transition) |
|
|
|
|
| def test_shared_renderer_rejects_duplicate_and_empty_v3_bundles() -> None: |
| row = _v3_row("agent:reviewer", actionability="manual", score=600_000) |
|
|
| for rows in ([], [row, row]): |
| with pytest.raises(RecommendationPresentationError, match="invalid PresentBundle"): |
| render_present_bundle_context(_v3_transition(rows)) |
|
|
|
|
| def test_shared_renderer_defensively_rejects_more_than_five_v3_rows() -> None: |
| rows = [ |
| _v3_row(f"agent:reviewer-{index}", actionability="manual", score=600_000 - index) |
| for index in range(6) |
| ] |
| transition = _v3_transition(rows[:1]) |
| action = transition.actions[0] |
| object.__setattr__( |
| action, |
| "payload", |
| {"plan_digest": _digest("v3-plan"), "capabilities": tuple(rows)}, |
| ) |
|
|
| with pytest.raises(RecommendationPresentationError, match="invalid PresentBundle"): |
| render_present_bundle_context(transition) |
|
|
|
|
| def test_renderers_reject_mixed_or_unbound_v2_rows() -> None: |
| transition = _transition() |
| bundle = transition.actions[0] |
| rows = [dict(raw) for raw in bundle.payload["capabilities"]] |
| rows[0]["install_descriptor_digest"] = "8" * 64 |
| rows[0]["install_plan_digest"] = "9" * 64 |
| mixed = replace( |
| transition, |
| actions=( |
| replace( |
| bundle, |
| payload={ |
| "plan_digest": bundle.payload["plan_digest"], |
| "capabilities": rows, |
| }, |
| ), |
| ), |
| ) |
| with pytest.raises(RecommendationPresentationError, match="invalid PresentBundle"): |
| render_recommendation_context(mixed) |
|
|
| for row in rows: |
| row["install_descriptor_digest"] = None |
| row["install_plan_digest"] = None |
| unbound = replace( |
| transition, |
| actions=( |
| replace( |
| bundle, |
| payload={ |
| "plan_digest": bundle.payload["plan_digest"], |
| "capabilities": rows, |
| }, |
| ), |
| ), |
| ) |
| with pytest.raises(RecommendationPresentationError, match="invalid PresentBundle"): |
| render_recommendation_hook(unbound) |
|
|
|
|
| def test_renderers_abstain_when_transition_has_no_present_bundle() -> None: |
| transition = Transition( |
| event_id="event-abstained-1", |
| scope=_scope(), |
| from_revision=1, |
| to_revision=2, |
| diagnostics=({"code": "below-threshold"},), |
| ) |
|
|
| assert render_recommendation_context(transition) is None |
| assert render_recommendation_hook(transition) is None |
|
|
|
|
| def test_renderers_fail_closed_for_multiple_present_bundles() -> None: |
| transition = _transition() |
| bundle = transition.actions[0] |
| multiple = replace( |
| transition, |
| actions=(bundle, replace(bundle, action_id="action-present-2")), |
| ) |
|
|
| with pytest.raises(RecommendationPresentationError, match="at most one"): |
| render_recommendation_context(multiple) |
| with pytest.raises(RecommendationPresentationError, match="at most one"): |
| render_recommendation_hook(multiple) |
|
|
|
|
| def test_renderers_fail_closed_for_a_non_exact_capability_row() -> None: |
| transition = _transition() |
| bundle = transition.actions[0] |
| first = dict(bundle.payload["capabilities"][0]) |
| first["display_description"] = "untrusted free-form text" |
| malformed = replace( |
| transition, |
| actions=( |
| replace( |
| bundle, |
| payload={ |
| "plan_digest": bundle.payload["plan_digest"], |
| "capabilities": [ |
| first, |
| *bundle.payload["capabilities"][1:], |
| ], |
| }, |
| ), |
| ), |
| ) |
|
|
| with pytest.raises(RecommendationPresentationError, match="invalid PresentBundle"): |
| render_recommendation_context(malformed) |
| with pytest.raises(RecommendationPresentationError, match="invalid PresentBundle"): |
| render_recommendation_hook(malformed) |
|
|
|
|
| def test_renderers_have_no_ranking_or_legacy_orchestrator_dependencies() -> None: |
| modules = (recommendation_presentation, engine_adapter, engine_hook) |
| forbidden_imports = { |
| "ctx.adapters.claude_code.hooks.bundle_orchestrator", |
| "ctx.config", |
| "ctx.engine.planner", |
| "ctx.core.resolve.recommendations", |
| "ctx_config", |
| } |
|
|
| for module in modules: |
| source = inspect.getsource(module) |
| tree = ast.parse(source) |
| imported = { |
| alias.name |
| for node in ast.walk(tree) |
| if isinstance(node, ast.Import) |
| for alias in node.names |
| } | { |
| node.module |
| for node in ast.walk(tree) |
| if isinstance(node, ast.ImportFrom) and node.module is not None |
| } |
| assert imported.isdisjoint(forbidden_imports) |
| assert "sorted(" not in source |
| assert ".sort(" not in source |
|
|
