# -*- coding: utf-8 -*- """End-to-end host-seam tests for the live P4 reply path. The real AstrBot host is replaced only at the import boundary. Effect events use the actual unified-person registry so replay/idempotency and the live runtime's ledger projection remain exercised together. """ from __future__ import annotations import asyncio from copy import deepcopy import importlib from pathlib import Path import sys from types import SimpleNamespace import types import unittest from unittest.mock import patch sys.path.insert(0, str(Path(__file__).resolve().parent)) import _host_stub # noqa: E402 _host_stub.install() event_module = importlib.import_module("astrbot.api.event") event_module.filter.EventMessageType = SimpleNamespace( ALL="ALL", PRIVATE_MESSAGE="PRIVATE_MESSAGE", GROUP_MESSAGE="GROUP_MESSAGE" ) PACKAGE = "_p4_live_hook_companion" if PACKAGE not in sys.modules: package = types.ModuleType(PACKAGE) package.__path__ = [str(Path(__file__).resolve().parents[1])] sys.modules[PACKAGE] = package main = importlib.import_module(f"{PACKAGE}.main") contract = importlib.import_module(f"{PACKAGE}.context_orchestration") person_contract = importlib.import_module(f"{PACKAGE}.unified_person_contract") registry_module = importlib.import_module(f"{PACKAGE}.unified_person_registry") runtime_gate = importlib.import_module(f"{PACKAGE}.p4_runtime_gate") def _identity(subject_id: str) -> dict[str, str]: return { "companion_instance_id": "companion-live-test", "bot_account_id": "bot-live-test", "adapter_instance_id": "aiocqhttp-live-test", "subject_namespace": "aiocqhttp.user", "platform_subject_id": subject_id, } def _finalized_p3_state() -> dict: state = contract.new_context_state(scope="group", created_at="2026-07-30T00:00:00.000Z") contract.update_security(state, status="allowed", response_policy="inherit") for layer in contract.LAYERS: contract.complete_layer(state, layer) contract.finalize_state(state) assert state["finalized"] is True return state def _active_runtime_state() -> dict[str, str]: return { "schema_version": "p4.runtime_gate.state.v1", "authority": "private_companion_p4", "confinement_state": "active", "confinement_until": "2099-01-01T00:00:00Z", "warmth": "guarded", } def _high_risk_review(message_id: str) -> dict: return { "schema_version": "p4.review.v1", "verdict": "violation", "category": "doxxing", "confidence": 0.99, "risk_flags": [], "evidence": [{ "message_id": message_id, "code": "direct_instruction_override", "source": "current_message", }], } class _Event: def __init__(self, *, message_id: str = "live-msg-1", text: str = "ordinary message") -> None: self._sender_id = "sender-42" self.message_id = message_id self.message_str = text self.unified_msg_origin = "aiocqhttp:group-1" self.platform_name = "aiocqhttp" # These payload-like fields are never a P4 authority. self.sender_id = "forged-sender" self.user_id = "forged-user" self.result = None self.stopped = False def get_sender_id(self) -> str: return self._sender_id def get_group_id(self) -> str: return "group-1" def get_platform_name(self) -> str: return "aiocqhttp" def is_private_chat(self) -> bool: return False def set_result(self, value: object) -> None: self.result = value def stop_event(self) -> None: self.stopped = True class _ForgedEvent(_Event): """Prove that the final gate never reads event-controlled release claims.""" _POISONED = frozenset({ "authorized", "owner_authorized", "p4_state", "p4_runtime_state", "confinement_state", "confinement_until", "warmth", }) def __getattribute__(self, name: str): # type: ignore[no-untyped-def] if name in _ForgedEvent._POISONED: raise AssertionError(f"forged event field was read: {name}") return super().__getattribute__(name) class _ToolSet: def __init__(self) -> None: self.cleared = False def clear(self) -> None: self.cleared = True def _request() -> SimpleNamespace: return SimpleNamespace( system_prompt="Memory context must not reach the model", prompt="Bridge and external context must not reach the model", extra_user_content=[{"external": "untrusted"}], images=["memory-image"], image_urls=["https://external.invalid/image"], tool_calls=[{"name": "sensitive_tool"}], func_tool=_ToolSet(), ) class _Plain: def __init__(self, text: str) -> None: self.text = text class _LiveHost: """Small host with a real P4 effect registry and narrow observable seams.""" _p4_live_runtime_state_from_ledger = main.PrivateCompanionPlugin._p4_live_runtime_state_from_ledger _p4_live_authority = main.PrivateCompanionPlugin._p4_live_authority _p4_live_injection_candidate = staticmethod(main.PrivateCompanionPlugin._p4_live_injection_candidate) _p4_live_candidate_for_text = main.PrivateCompanionPlugin._p4_live_candidate_for_text _p4_live_mark_state = main.PrivateCompanionPlugin._p4_live_mark_state _p4_live_refresh_event_state = main.PrivateCompanionPlugin._p4_live_refresh_event_state _p4_live_clear_request_payload = staticmethod(main.PrivateCompanionPlugin._p4_live_clear_request_payload) _p4_manual_review_expiry = staticmethod(main.PrivateCompanionPlugin._p4_manual_review_expiry) _p4_manual_review_runtime_sender_id = staticmethod(main.PrivateCompanionPlugin._p4_manual_review_runtime_sender_id) _p4_manual_review_attestation_registry = main.PrivateCompanionPlugin._p4_manual_review_attestation_registry def __init__(self) -> None: self.enable_p4_live_runtime = True self.enable_p4_manual_review = True self.enabled = True self.assurance = "verified" self.intent: dict[str, str] = {"emotion_event": "neutral", "emotion_target": "none"} self.fail_effect_readback = False self.effect_write_seen = False self.effect_results: list[dict] = [] self.lifecycle_calls: list[tuple[str, tuple, dict]] = [] self.manual_candidates: dict[str, dict] = {} self.prompt_records: list[dict] = [] self.context_collector_calls = 0 self.fail_on_context_collection = False self.store = {"unified_person": person_contract.empty_unified_person_store()} self.registry = registry_module.UnifiedPersonRegistry(self.store) observed = self.registry.upsert_observed_identity( _identity("sender-42"), operation_id="observe-live-sender-42" ) assert observed["ok"] is True self.person_id = observed["person_id"] self._p4_manual_review_registry = main._new_p4_review_attestation_registry() @staticmethod def _p4_live_now_iso() -> str: return "2026-07-30T12:00:00Z" @staticmethod def _safe_event_sender_id(event: _Event) -> str: try: return str(event.get_sender_id()) except Exception: return "" @staticmethod def _event_message_id(event: _Event) -> str: return str(event.message_id or "") def _memory_companion_unified_person_authority(self, event: _Event, *, expected_user_id: str = "") -> dict: if expected_user_id != "sender-42": return {} return { "unified_person_projection": { "person_id": self.person_id, "profile_status": "active", "identity_assurance": self.assurance, }, "unified_person_source_identity": {"platform_subject_id": "sender-42"}, } def _analyze_inbound_intent(self, text: str) -> dict: del text return dict(self.intent) async def _p4_live_append_warmth_to_request(self, event: _Event, req: SimpleNamespace) -> None: self.context_collector_calls += 1 if self.fail_on_context_collection: raise AssertionError("P4 confinement should skip every context collector") await main.PrivateCompanionPlugin._p4_live_append_warmth_to_request(self, event, req) @staticmethod def _append_turn_prompt_fragment_by_position(*args, **kwargs) -> bool: del args, kwargs return False async def _record_request_prompt_fragment(self, event: _Event, **kwargs) -> None: del event self.prompt_records.append(deepcopy(kwargs)) @staticmethod def _safe_event_is_private(event: _Event) -> bool: del event return False @staticmethod def _build_result_from_chain(chain: list[object]) -> list[object]: return list(chain) def _apply_unified_person_lifecycle(self, operation: str, *args, **kwargs) -> dict: # Producer attestations are deliberately opaque/non-serializable. The # host log retains only ordinary operation metadata and never attempts # to clone the capability handle. logged_kwargs = { key: deepcopy(value) for key, value in kwargs.items() if key not in {"producer_attestation", "producer_request", "producer_event", "producer_state"} } self.lifecycle_calls.append((operation, args, logged_kwargs)) if operation == "read_p4_effect_state": if self.fail_effect_readback and self.effect_write_seen: return {"ok": False, "code": "p4_effect_readback_failed"} return self.registry.read_p4_effect_state(args[0]) if operation == "record_p4_effect_event": self.effect_write_seen = True result = self.registry.record_p4_effect_event( args[0], args[1], operation_id=kwargs["operation_id"], actor_id=kwargs.get("actor_id", "system"), ) self.effect_results.append(deepcopy(result)) return result if operation == "record_p4_manual_review_candidate": candidate = deepcopy(args[1]) candidate_id = candidate["candidate_id"] if candidate_id in self.manual_candidates: return {"ok": True, "code": "p4_review_candidate_duplicate", "candidate_id": candidate_id} self.manual_candidates[candidate_id] = candidate return {"ok": True, "code": "p4_review_candidate_recorded", "candidate_id": candidate_id} return {"ok": False, "code": "unsupported_lifecycle_operation"} def _seed_third_confinement(host: _LiveHost) -> None: """Build rounds 1/2/3 by replaying real high-risk effect events.""" events = [ ("third-v1", "2026-07-01T00:00:00Z", "violation"), ("third-expiry-1", "2026-07-11T00:00:00Z", "confinement_expiry"), ("third-v2", "2026-07-12T00:00:00Z", "violation"), ("third-expiry-2", "2026-07-22T00:00:00Z", "confinement_expiry"), ("third-v3", "2026-07-23T00:00:00Z", "violation"), ] for event_id, occurred_at, kind in events: event = {"event_id": event_id, "occurred_at": occurred_at, "kind": kind} if kind == "violation": event["review"] = _high_risk_review(f"review-{event_id}") result = host.registry.record_p4_effect_event( host.person_id, event, operation_id=f"seed-{event_id}", actor_id="p4-live-hook-test", ) assert result["ok"] is True class P4LiveHookTests(unittest.TestCase): def test_live_hook_writes_effect_ledger_and_replay_is_idempotent(self) -> None: host = _LiveHost() event = _Event(message_id="replay-message", text="hello") asyncio.run(main.PrivateCompanionPlugin.observe_p4_live_inbound(host, event)) first = host.registry.read_p4_effect_state(host.person_id) self.assertTrue(first["ok"]) self.assertEqual(1, first["event_count"]) self.assertEqual("normal", first["p4_effect_state"]["event_log"][0]["kind"]) first_event_id = first["p4_effect_state"]["event_log"][0]["event_id"] asyncio.run(main.PrivateCompanionPlugin.observe_p4_live_inbound(host, event)) replay = host.registry.read_p4_effect_state(host.person_id) self.assertEqual(1, replay["event_count"]) self.assertEqual(first_event_id, replay["p4_effect_state"]["event_log"][0]["event_id"]) self.assertEqual(2, len(host.effect_results)) self.assertTrue(host.effect_results[-1].get("idempotent")) def test_positive_event_projects_warmth_fragment_without_security_change(self) -> None: host = _LiveHost() host.intent = {"emotion_event": "praise", "emotion_target": "bot"} event = _Event(message_id="warm-message", text="thank you") request = _request() asyncio.run(main.PrivateCompanionPlugin.prepare_p4_live_runtime_request(host, event, request)) effect = host.registry.read_p4_effect_state(host.person_id) self.assertEqual(1, effect["p4_effect_state"]["score"]) runtime_state = getattr(event, "_private_companion_p4_live_runtime_state") self.assertEqual("warm", runtime_state["warmth"]) self.assertEqual( {"schema_version", "authority", "confinement_state", "confinement_until", "warmth"}, set(runtime_state), ) asyncio.run(host._p4_live_append_warmth_to_request(event, request)) self.assertIn("", request.system_prompt) self.assertEqual("warm", host.prompt_records[-1]["metadata"]["tier"]) self.assertFalse(getattr(event, "_private_companion_p4_confinement_active")) def test_active_and_invalid_state_skip_collectors_and_send_fixed_reply(self) -> None: # Active state: skip Memory/Bridge/tool/external collectors before they # can consume the request, then seal the result immediately before send. host = _LiveHost() host.fail_on_context_collection = True active_event = _Event(message_id="active-message") setattr(active_event, "_private_companion_p4_confinement_active", True) active_request = _request() asyncio.run(main.PrivateCompanionPlugin.inject_humanized_state(host, active_event, active_request)) self.assertEqual(0, host.context_collector_calls) self._assert_request_cleared(active_request) setattr(active_event, "_private_companion_p4_live_scope_resolved", True) setattr(active_event, "_private_companion_p4_live_runtime_state", _active_runtime_state()) asyncio.run(main.PrivateCompanionPlugin.enforce_p4_live_confinement_request(host, active_event, active_request)) self._assert_request_cleared(active_request) self._assert_fixed_reply_before_send(host, active_event) # The event was written, but an authoritative post-write effect read # failed. The live hook must mark it as invalid/active, skip collectors, # and block at the final gate rather than use its stale pre-write state. invalid_host = _LiveHost() invalid_host.fail_effect_readback = True invalid_event = _Event(message_id="invalid-readback") asyncio.run(main.PrivateCompanionPlugin.observe_p4_live_inbound(invalid_host, invalid_event)) persisted = invalid_host.registry.read_p4_effect_state(invalid_host.person_id) self.assertEqual(1, persisted["event_count"]) self.assertTrue(getattr(invalid_event, "_private_companion_p4_live_state_invalid")) self.assertTrue(getattr(invalid_event, "_private_companion_p4_confinement_active")) self.assertIsNone(getattr(invalid_event, "_private_companion_p4_live_runtime_state")) invalid_host.fail_on_context_collection = True invalid_request = _request() asyncio.run(main.PrivateCompanionPlugin.inject_humanized_state(invalid_host, invalid_event, invalid_request)) self.assertEqual(0, invalid_host.context_collector_calls) self._assert_request_cleared(invalid_request) asyncio.run(main.PrivateCompanionPlugin.enforce_p4_live_confinement_request(invalid_host, invalid_event, invalid_request)) self._assert_fixed_reply_before_send(invalid_host, invalid_event) def test_forged_event_fields_cannot_release_active_confinement(self) -> None: host = _LiveHost() event = _ForgedEvent(message_id="forged-release") # They are deliberately poisoned if the gate attempts to inspect them. object.__setattr__(event, "authorized", True) object.__setattr__(event, "owner_authorized", True) object.__setattr__(event, "p4_state", {"confinement_state": "none"}) object.__setattr__(event, "p4_runtime_state", {"confinement_state": "none"}) object.__setattr__(event, "confinement_state", "none") object.__setattr__(event, "confinement_until", "") object.__setattr__(event, "warmth", "close") setattr(event, "_private_companion_p4_live_scope_resolved", True) setattr(event, "_private_companion_p4_live_runtime_state", _active_runtime_state()) request = _request() asyncio.run(main.PrivateCompanionPlugin.enforce_p4_live_confinement_request(host, event, request)) self.assertTrue(getattr(event, "_private_companion_p4_confinement_active")) self._assert_request_cleared(request) self._assert_fixed_reply_before_send(host, event) def test_third_confinement_reads_effect_state_and_emits_one_candidate(self) -> None: host = _LiveHost() _seed_third_confinement(host) effect = host.registry.read_p4_effect_state(host.person_id) self.assertEqual("active", effect["p4_effect_state"]["confinement_state"]) self.assertEqual(3, effect["p4_effect_state"]["confinement_round"]) for message_id in ("review-message-1", "review-message-2"): event = _Event(message_id=message_id) request = SimpleNamespace(system_prompt="unchanged") state = _finalized_p3_state() contract.attach_context_state(state, request, event) asyncio.run(main.PrivateCompanionPlugin.observe_p4_manual_review_candidate(host, event, request)) self.assertEqual("unchanged", request.system_prompt) reads = [call for call in host.lifecycle_calls if call[0] == "read_p4_effect_state"] self.assertEqual(2, len(reads)) self.assertEqual(1, len(host.manual_candidates)) candidate = next(iter(host.manual_candidates.values())) self.assertEqual(host.person_id, candidate["person_id"]) self.assertEqual("third_confinement_review_required", candidate["reason_code"]) self.assertNotIn("review-message-1", repr(candidate)) self.assertNotIn("review-message-2", repr(candidate)) def _assert_request_cleared(self, request: SimpleNamespace) -> None: self.assertEqual("", request.system_prompt) self.assertEqual("", request.prompt) self.assertEqual([], request.extra_user_content) self.assertEqual([], request.images) self.assertEqual([], request.image_urls) self.assertEqual([], request.tool_calls) self.assertTrue(request.func_tool.cleared) self.assertEqual("blocked", getattr(request, "_private_companion_p4_runtime_gate")) def _assert_fixed_reply_before_send(self, host: _LiveHost, event: _Event) -> None: fixed_reply = getattr(event, "_private_companion_p4_fixed_reply") self.assertEqual(runtime_gate.SAFE_CONFINEMENT_REPLY, fixed_reply) with patch.object(main, "Plain", _Plain): asyncio.run(main.PrivateCompanionPlugin.enforce_p4_live_confinement_reply_before_send(host, event)) self.assertTrue(event.stopped) self.assertIsInstance(event.result, list) self.assertEqual(1, len(event.result)) self.assertIsInstance(event.result[0], _Plain) self.assertEqual(runtime_gate.SAFE_CONFINEMENT_REPLY, event.result[0].text) if __name__ == "__main__": unittest.main()