From 23c57cc84ffba6d5e01bf0f9ce49011c8a9c8141 Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Wed, 29 Jul 2026 21:32:53 +0800 Subject: [PATCH] feat: add P3 orchestration and P4 shadow settlement --- README.md | 8 + context_orchestration.py | 192 ++++ core_store.py | 1 + main.py | 230 ++++- memory_companion_adapter.py | 31 +- p4_affinity_confinement.py | 963 +++++++++++++++++++ p4_capabilities.py | 153 +++ prompt_surface.py | 9 +- tests/fixtures/context_orchestration_v1.json | 1 + tests/test_p2_unified_person_bridge.py | 21 +- tests/test_p3_context_orchestration.py | 86 ++ tests/test_p4_affinity_confinement.py | 233 +++++ tests/test_p4_capabilities.py | 113 +++ tests/test_p4_joint_workspace.py | 155 +++ tests/test_p4_shadow_hook.py | 243 +++++ tests/test_p4_shadow_registry.py | 249 +++++ unified_person_registry.py | 312 ++++++ 17 files changed, 2984 insertions(+), 16 deletions(-) create mode 100644 context_orchestration.py create mode 100644 p4_affinity_confinement.py create mode 100644 p4_capabilities.py create mode 100644 tests/fixtures/context_orchestration_v1.json create mode 100644 tests/test_p3_context_orchestration.py create mode 100644 tests/test_p4_affinity_confinement.py create mode 100644 tests/test_p4_capabilities.py create mode 100644 tests/test_p4_joint_workspace.py create mode 100644 tests/test_p4_shadow_hook.py create mode 100644 tests/test_p4_shadow_registry.py diff --git a/README.md b/README.md index 877bc29..b2b1056 100644 --- a/README.md +++ b/README.md @@ -157,6 +157,14 @@ openid=主用户ID - 插件不会仅凭昵称自动合并身份。 - “主要用户”会获得插件管理权限,但权限只认真实发送者 ID;身份别名不会把另一个发送者一并提升为管理员。 +### P4-A 影子账本(默认关闭) + +当前开发阶段提供 enable_p4_shadow_observer 开关,默认关闭。开启后,插件只会在 P3 安全编排完成后,为具备精确、已验证或显式关联身份且拥有稳定消息 ID 的会话写入独立影子账本。 + +- 影子账本不会修改现有 relationship_score、人物投影、忽略门、普通 LLM 回复或任何实际管理命令结果。 +- 消息正文不写入 P4 账本;稳定消息 ID 仅以摘要形式用于幂等审计。 +- 好感实时加减、警告、禁闭、释放语、恢复消费和 owner 命令执行均未启用,仍须等待后续 P4-B 授权和验收。 + ## 核心工作方式 ### 被动回复 diff --git a/context_orchestration.py b/context_orchestration.py new file mode 100644 index 0000000..e5ee47c --- /dev/null +++ b/context_orchestration.py @@ -0,0 +1,192 @@ +# -*- coding: utf-8 -*- +"""P3 versioned, metadata-only request context contract.""" +from __future__ import annotations + +import hashlib +import json +import re +from copy import deepcopy +from datetime import datetime, timezone +from typing import Any + +CONTRACT_NAME = "ops.context_orchestration.v1" +CONTRACT_VERSION = "1.0" +ATTRIBUTE_NAME = "_ops_context_orchestration_v1" +LAYERS = ("persona", "runtime", "person", "scene", "memory", "safety") +PHASES = ("initialized", "companion_ready", "memory_ready", "safety_ready", "finalized", "invalid") +SECURITY_STATUSES = ("allowed", "sanitized", "blocked", "quarantined", "unavailable") +POLICIES = ("inherit", "allow", "deny", "quarantine") +TRUST_LEVELS = ("T0", "T1", "T2", "T3", "T4") +CONTEXT_INIT, COMPANION_CONTEXT, TTS_FALLBACK, MEMORY_CONTEXT = 100, 0, -10, -20 +INCOMPATIBLE_TOOL, SENSITIVE_TOOL, FINALIZE = -20000, -21000, -22000 +MAX_FRAGMENTS, MAX_ERRORS, MAX_REASON_CODES = 64, 16, 16 +_FRAGMENT_FIELDS = ("key", "layer", "source", "trust_level", "content_hash", "chars", "status") +_CORE = ("persona", "runtime", "person", "scene") +_STATE_FIELDS = {"contract_name", "contract_version", "contract_fingerprint", "request_id", "session_id", "scope", "created_at", "phase", "completed_layers", "fragments", "security", "errors", "finalized"} +_SECURITY_FIELDS = {"status", "event_id", "memory_policy", "tool_policy", "response_policy", "reason_codes"} +_CODE_RE = re.compile(r"^[a-z0-9][a-z0-9_.:-]{0,119}$") + + +def _json(value: Any) -> str: + return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + + +def contract_descriptor(*, fixture_version: str = "1") -> dict[str, Any]: + return {"contract_name": CONTRACT_NAME, "contract_version": CONTRACT_VERSION, "attribute_name": ATTRIBUTE_NAME, "fixture_version": str(fixture_version), "layers": list(LAYERS), "phases": list(PHASES), "security_statuses": list(SECURITY_STATUSES), "policies": list(POLICIES), "trust_levels": list(TRUST_LEVELS), "state_fields": ["contract_name", "contract_version", "contract_fingerprint", "request_id", "session_id", "scope", "created_at", "phase", "completed_layers", "fragments", "security", "errors", "finalized"], "security_fields": ["status", "event_id", "memory_policy", "tool_policy", "response_policy", "reason_codes"], "fragment_fields": list(_FRAGMENT_FIELDS), "limits": {"fragments": MAX_FRAGMENTS, "errors": MAX_ERRORS, "reason_codes": MAX_REASON_CODES}} + + +def contract_fingerprint(*, fixture_version: str = "1") -> str: + return hashlib.sha256(_json(contract_descriptor(fixture_version=fixture_version)).encode("utf-8")).hexdigest() + + +def _text(value: Any, limit: int = 240) -> str: + return str(value or "").replace("\r", " ").replace("\n", " ").strip()[:limit] + + +def _utc_timestamp(value: Any = None) -> str: + if value is None: + return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z") + if not isinstance(value, str) or value != value.strip() or "T" not in value or not value.endswith("Z"): + return "" + try: + datetime.fromisoformat(value[:-1] + "+00:00") + except ValueError: + return "" + return value + + +def _security() -> dict[str, Any]: + return {"status": "allowed", "event_id": "", "memory_policy": "inherit", "tool_policy": "inherit", "response_policy": "inherit", "reason_codes": []} + + +def new_context_state(*, request_id: Any = "", session_id: Any = "", scope: Any = "unknown", created_at: Any = None, fixture_version: str = "1") -> dict[str, Any]: + return {"contract_name": CONTRACT_NAME, "contract_version": CONTRACT_VERSION, "contract_fingerprint": contract_fingerprint(fixture_version=fixture_version), "request_id": _text(request_id, 180), "session_id": _text(session_id), "scope": _text(scope, 80) or "unknown", "created_at": _utc_timestamp(created_at), "phase": "initialized", "completed_layers": [], "fragments": [], "security": _security(), "errors": [], "finalized": False} + + +def _error(state: dict[str, Any], code: str) -> None: + errors = state.setdefault("errors", []) + if isinstance(errors, list) and code not in errors and len(errors) < MAX_ERRORS: + errors.append(code) + + +def _invalid(state: dict[str, Any], code: str) -> dict[str, Any]: + _error(state, code); state["phase"] = "invalid"; state["finalized"] = False + return state + + +def consume_context_state(value: Any, *, fixture_version: str = "1") -> dict[str, Any] | None: + if not isinstance(value, dict): return None + state = value + if state.get("contract_name") != CONTRACT_NAME or state.get("contract_version") != CONTRACT_VERSION: return _invalid(state, "contract_mismatch") + if state.get("contract_fingerprint") != contract_fingerprint(fixture_version=fixture_version): return _invalid(state, "fingerprint_mismatch") + if set(state) != _STATE_FIELDS or state.get("phase") not in PHASES or not isinstance(state.get("finalized"), bool): return _invalid(state, "state_invalid") + if not isinstance(state.get("created_at"), str) or not state["created_at"] or _utc_timestamp(state["created_at"]) != state["created_at"]: return _invalid(state, "created_at_invalid") + completed = state.get("completed_layers") + if not isinstance(completed, list): return _invalid(state, "state_invalid") + if any(layer not in LAYERS for layer in completed) or len(completed) != len(set(completed)) or completed != sorted(completed, key=LAYERS.index): return _invalid(state, "completed_layers_invalid") + if state["finalized"] != (state["phase"] == "finalized"): return _invalid(state, "finalized_phase_invalid") + if state["finalized"] and set(completed) != set(LAYERS): return _invalid(state, "finalized_layers_invalid") + if not isinstance(state.get("fragments"), list) or len(state["fragments"]) > MAX_FRAGMENTS: return _invalid(state, "fragments_invalid") + for fragment in state["fragments"]: + if not isinstance(fragment, dict) or set(fragment) != set(_FRAGMENT_FIELDS) or fragment.get("layer") not in LAYERS or fragment.get("trust_level") not in TRUST_LEVELS: return _invalid(state, "fragment_invalid") + security = state.get("security") + if not isinstance(security, dict) or set(security) != _SECURITY_FIELDS or security.get("status") not in SECURITY_STATUSES or any(security.get(key) not in POLICIES for key in ("memory_policy", "tool_policy", "response_policy")): return _invalid(state, "security_invalid") + errors = state.get("errors") + reason_codes = security.get("reason_codes") + if not isinstance(reason_codes, list) or len(reason_codes) > MAX_REASON_CODES or not isinstance(errors, list) or len(errors) > MAX_ERRORS: return _invalid(state, "limits_invalid") + if any(not isinstance(code, str) or _CODE_RE.fullmatch(code) is None for code in [*errors, *reason_codes]): return _invalid(state, "codes_invalid") + return state + + +def attach_context_state(state: dict[str, Any], request: Any | None = None, event: Any | None = None) -> dict[str, Any]: + for carrier in (request, event): + if carrier is not None: + try: setattr(carrier, ATTRIBUTE_NAME, state) + except Exception: pass + return state + + +def read_context_state(request: Any | None = None, event: Any | None = None, *, fixture_version: str = "1") -> dict[str, Any] | None: + for carrier in (request, event): + state = consume_context_state(getattr(carrier, ATTRIBUTE_NAME, None) if carrier is not None else None, fixture_version=fixture_version) + if state is not None: + attach_context_state(state, request, event) + return state + return None + + +def _refresh(state: dict[str, Any]) -> None: + if state["phase"] == "invalid" or state["finalized"]: return + completed = set(state["completed_layers"]) + state["phase"] = "safety_ready" if "safety" in completed else "memory_ready" if "memory" in completed else "companion_ready" if set(_CORE).issubset(completed) else "initialized" + + +def _open(state: dict[str, Any]) -> bool: + return consume_context_state(state) is not None and state.get("phase") != "invalid" and not state.get("finalized") + + +def complete_layer(state: dict[str, Any], layer: str) -> dict[str, Any]: + if not _open(state): return state + if layer not in LAYERS: return _invalid(state, "layer_invalid") + if layer not in state["completed_layers"]: + state["completed_layers"].append(layer) + state["completed_layers"].sort(key=LAYERS.index) + _refresh(state); return state + + +def register_fragment(state: dict[str, Any], *, key: Any, layer: str, source: Any = "", trust_level: str = "T2", content: Any = None, content_hash: Any = "", chars: Any = None, status: Any = "allowed") -> dict[str, Any]: + if not _open(state): return state + if layer not in LAYERS or trust_level not in TRUST_LEVELS: return _invalid(state, "fragment_invalid") + raw = "" if content is None else str(content) + try: size = max(0, int(len(raw) if chars is None else chars)) + except (TypeError, ValueError): return _invalid(state, "fragment_chars_invalid") + item = {"key": _text(key, 120) or "fragment", "layer": layer, "source": _text(source, 120), "trust_level": trust_level, "content_hash": _text(content_hash, 128) or hashlib.sha256(raw.encode("utf-8")).hexdigest(), "chars": size, "status": _text(status, 40) or "allowed"} + for old in state["fragments"]: + if old == item: return state + if old.get("key") == item["key"]: return _invalid(state, "fragment_key_conflict") + if len(state["fragments"]) >= MAX_FRAGMENTS: return _invalid(state, "fragment_limit") + state["fragments"].append(item); return state + + +def update_security(state: dict[str, Any], *, status: str | None = None, event_id: Any = None, memory_policy: str | None = None, tool_policy: str | None = None, response_policy: str | None = None, reason_codes: Any = None) -> dict[str, Any]: + if not _open(state): return state + security = state["security"] + if status is not None: + if status not in SECURITY_STATUSES: return _invalid(state, "security_status_invalid") + security["status"] = status + for key, value in (("memory_policy", memory_policy), ("tool_policy", tool_policy), ("response_policy", response_policy)): + if value is not None: + if value not in POLICIES: return _invalid(state, "security_policy_invalid") + security[key] = value + if event_id is not None: security["event_id"] = _text(event_id, 180) + codes = [reason_codes] if isinstance(reason_codes, str) else (reason_codes or []) + if not isinstance(codes, (list, tuple, set)): return _invalid(state, "reason_codes_invalid") + for code in codes: + if not isinstance(code, str) or _CODE_RE.fullmatch(code) is None: return _invalid(state, "reason_code_invalid") + if code not in security["reason_codes"] and len(security["reason_codes"]) < MAX_REASON_CODES: security["reason_codes"].append(code) + return state + + +def finalize_state(state: dict[str, Any]) -> dict[str, Any]: + if not _open(state): return state + if set(LAYERS).issubset(set(state["completed_layers"])): + state["phase"], state["finalized"] = "finalized", True + else: + _error(state, "finalize_pending_layers") + return state + + +def project_context_state(state: dict[str, Any] | None) -> dict[str, Any] | None: + state = consume_context_state(state) + if state is None: return None + return deepcopy({key: state[key] for key in ("contract_name", "contract_version", "contract_fingerprint", "request_id", "session_id", "scope", "created_at", "phase", "completed_layers", "fragments", "security", "errors", "finalized")}) + + +def infer_context_layer(key: Any = "", source: Any = "") -> str: + text = f"{key or ''} {source or ''}".lower() + if any(token in text for token in ("memory", "recall")): return "memory" + if any(token in text for token in ("safety", "guard", "tool", "tts", "privacy", "sanitize")): return "safety" + if any(token in text for token in ("persona", "reply.style", "identity", "character")): return "persona" + if any(token in text for token in ("private.context", "preferred_address", "preferred address", "relationship", "nickname", "person", "user.")): return "person" + if any(token in text for token in ("runtime", "state", "schedule", "temporal", "weather", "food", "agenda", "time")): return "runtime" + return "scene" diff --git a/core_store.py b/core_store.py index bbd3a9e..21e527b 100644 --- a/core_store.py +++ b/core_store.py @@ -631,6 +631,7 @@ class CoreStoreMixin: "unlink_identity", "merge_people", "split_merged_people", + "record_p4_shadow_event", }: return {"ok": False, "code": "unsupported_lifecycle_operation"} result = operation(*args, **kwargs) diff --git a/main.py b/main.py index c0abecd..59a26a1 100644 --- a/main.py +++ b/main.py @@ -131,6 +131,12 @@ from .calendar_system import CalendarEventError from .forward_message import ForwardMessageMixin from .private_image import PrivateImageMixin from .prompt_surface import PromptSurface +from .context_orchestration import ( + COMPANION_CONTEXT, CONTEXT_INIT, FINALIZE, INCOMPATIBLE_TOOL, + SENSITIVE_TOOL, TTS_FALLBACK, attach_context_state, complete_layer, + finalize_state, new_context_state, read_context_state, register_fragment, + update_security, +) from .segmented_message import flatten_component_chunks, split_plain_component_chain_detailed from .token_budget import TokenBudgetMixin from .balance_awareness import BalanceAwarenessMixin @@ -187,6 +193,8 @@ from .planning import ( pick_detail_segment, ) +P4_SHADOW_OBSERVER_PRIORITY = FINALIZE - 1000 + _private_companion_plugin: Any | None = None DEFAULT_AI_DAILY_MORNING_UID = "3706929260006322" @@ -1909,6 +1917,10 @@ class PrivateCompanionPlugin( self.unified_person_subject_namespace_map = self._cfg_raw( c, "unified_person_subject_namespace_map", "" ) + # P4-A is intentionally opt-in and shadow-only. It may persist a + # separate audit ledger, but it never changes a live score, reply, + # ignore gate, or management-command outcome. + self.enable_p4_shadow_observer = self._cfg_bool(c, "enable_p4_shadow_observer", False) self.memory_companion_context_timeout_seconds = self._cfg_float(c, "memory_companion_context_timeout_seconds", 1.2, 0.2) self.enable_memory_companion_emotional_drift = self._cfg_bool(c, "enable_memory_companion_emotional_drift", True) self.enable_memory_companion_cross_window_emotion = self._cfg_bool(c, "enable_memory_companion_cross_window_emotion", True) @@ -8115,7 +8127,24 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge _single_line(text, 80) or "非文本消息", ) - @filter.on_llm_request() + @filter.on_llm_request(priority=CONTEXT_INIT) + async def initialize_context_orchestration(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs): + if req is None: + return + state = read_context_state(request=req, event=event) + if state is None: + try: + scope = "private" if bool(getattr(event, "is_private_chat", lambda: False)()) else "group" + except Exception: + scope = "unknown" + state = new_context_state( + request_id=_single_line(getattr(req, "request_id", "") or getattr(req, "id", ""), 180), + session_id=_single_line(getattr(event, "unified_msg_origin", ""), 240), + scope=scope, + ) + attach_context_state(state, req, event) + + @filter.on_llm_request(priority=TTS_FALLBACK) async def inject_tts_enhancement_request_fallback(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs): """TTS 请求规则独立兜底,避免被状态注入链路早退顺手跳过。""" if self is None or not self.enabled: @@ -8352,7 +8381,71 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge mode="private" if self._safe_event_is_private(event) else "group", ) - @filter.on_llm_request(priority=-21000) + def _prepare_context_orchestration_for_memory( + self, + event: AstrMessageEvent, + req: ProviderRequest, + prompt_surface: PromptSurface, + expected_user_id: str = "", + ) -> dict[str, Any] | None: + state = read_context_state(request=req, event=event) + if state is None or state.get("phase") == "invalid": + return None + evidence: set[str] = set() + system_prompt = str(getattr(req, "system_prompt", "") or "").strip() + if system_prompt: + register_fragment( + state, key="persona.system_prompt", layer="persona", + source="provider_request", trust_level="T1", content=system_prompt, + ) + evidence.add("persona") + scene_text = str(getattr(event, "message_str", "") or "").strip() + if scene_text: + register_fragment( + state, key="scene.current_turn", layer="scene", + source="message_event", trust_level="T2", content=scene_text, + ) + evidence.add("scene") + for fragment in prompt_surface.rendered_fragments(): + layer = str(fragment.get("layer", "scene")) + register_fragment( + state, key=fragment.get("key", ""), layer=layer, + source=fragment.get("source", ""), trust_level="T2", + content=fragment.get("content", ""), chars=fragment.get("chars", 0), + ) + if layer in {"persona", "runtime", "scene"}: + evidence.add(layer) + for layer in evidence: + complete_layer(state, layer) + authority = self._memory_companion_unified_person_authority( + event, + expected_user_id=expected_user_id or self._safe_event_sender_id(event), + ) + if ( + isinstance(authority, dict) + and + isinstance(authority.get("unified_person_projection"), dict) + and isinstance(authority.get("unified_person_source_identity"), dict) + ): + register_fragment( + state, key="unified_person.authority", layer="person", + source="unified_person", trust_level="T0", + content_hash=hashlib.sha256(b"unified_person_authority.v1").hexdigest(), chars=0, + ) + complete_layer(state, "person") + else: + update_security(state, reason_codes="person_authority_unavailable") + attach_context_state(state, req, event) + return state + + @staticmethod + def _mark_context_tools_sanitized(event: AstrMessageEvent, req: ProviderRequest, reason_code: str) -> None: + state = read_context_state(request=req, event=event) + if state is not None: + update_security(state, status="sanitized", tool_policy="deny", reason_codes=reason_code) + attach_context_state(state, req, event) + + @filter.on_llm_request(priority=SENSITIVE_TOOL) async def sanitize_sensitive_screen_tools(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs): """屏幕工具只能保留给已启用的主要用户私聊,群聊和第三方场景一律裁掉。""" if self is None or req is None: @@ -8360,8 +8453,9 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge removed = self._remove_sensitive_screen_tools_from_request(event, req) if removed: await self._append_sensitive_screen_tool_guard_to_request(event, req, removed) + self._mark_context_tools_sanitized(event, req, "sensitive_tool_removed") - @filter.on_llm_request(priority=-20000) + @filter.on_llm_request(priority=INCOMPATIBLE_TOOL) async def sanitize_incompatible_web_search_tools(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs): """移除 Gemini/OpenAI 兼容层会拒绝的 Baidu AI Search MCP 工具声明。""" if self is None or req is None: @@ -8398,7 +8492,9 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge umo or "unknown", ) - @filter.on_llm_request() + self._mark_context_tools_sanitized(event, req, "incompatible_tool_removed") + + @filter.on_llm_request(priority=COMPANION_CONTEXT) async def inject_humanized_state(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs): """LLM 请求前注入陪伴状态、群聊上下文、工具边界和合并消息阅读上下文。""" if self is None: @@ -8917,6 +9013,10 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge priority=20, source="environment", ) + self._prepare_context_orchestration_for_memory( + event, req, prompt_surface, + expected_user_id=private_user_id if is_private_chat else self._safe_event_sender_id(event), + ) rest_backlog_prompt = self._take_rest_reply_backlog_prompt(current_user) if rest_backlog_prompt: prompt_surface.add( @@ -9400,6 +9500,10 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge if creative_reply_context: setattr(event, "private_companion_creative_reply_context", creative_reply_context) self._add_collected_prompt_contexts(prompt_surface, collected_contexts) + self._prepare_context_orchestration_for_memory( + event, req, prompt_surface, + expected_user_id=private_user_id if is_private_chat else self._safe_event_sender_id(event), + ) static_fragment_keys = {"reply.style"} static_injection, dynamic_injection = prompt_surface.render_partition( lambda fragment: fragment.normalized_key() in static_fragment_keys @@ -9491,6 +9595,124 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge current_schedule, ) + @filter.on_llm_request(priority=FINALIZE) + async def finalize_context_orchestration(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs): + state = read_context_state(request=req, event=event) + if state is None: + return + if state.get("phase") != "invalid": + complete_layer(state, "safety") + finalize_state(state) + attach_context_state(state, req, event) + + @filter.on_llm_request(priority=P4_SHADOW_OBSERVER_PRIORITY) + async def record_p4_shadow_normal_observer(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs): + """Append one P4-A normal shadow event after the immutable P3 finalizer. + + This observer is deliberately fail-closed and has no response-path + effects. It never creates a person, falls back to a legacy user ID, + changes the P3 carrier, or calls a live affinity/confinement path. + """ + if self is None or event is None or req is None: + return + if not bool(getattr(self, "enable_p4_shadow_observer", False)): + return + try: + state = read_context_state(request=req, event=event) + except Exception as exc: + logger.debug( + "[PrivateCompanion] P4 shadow observer skipped after context-read error: %s", + _single_line(exc, 160), + ) + return + if not isinstance(state, dict) or state.get("phase") != "finalized" or state.get("finalized") is not True: + return + security = state.get("security") + if not isinstance(security, dict): + return + if security.get("status") not in {"allowed", "sanitized"}: + return + # A denied P3 response remains denied: P4-A must not turn that turn + # into a recovery candidate, even in its separate shadow ledger. + if security.get("response_policy") == "deny": + return + occurred_at = state.get("created_at") + if not isinstance(occurred_at, str) or not occurred_at: + return + try: + message_id = self._event_message_id(event) + except Exception as exc: + logger.debug( + "[PrivateCompanion] P4 shadow observer skipped after message-id error: %s", + _single_line(exc, 160), + ) + return + if not message_id: + return + try: + authority = self._memory_companion_unified_person_authority( + event, + expected_user_id=self._safe_event_sender_id(event), + ) + except Exception as exc: + logger.debug( + "[PrivateCompanion] P4 shadow observer skipped after authority error: %s", + _single_line(exc, 160), + ) + return + projection = authority.get("unified_person_projection") if isinstance(authority, dict) else None + source_identity = authority.get("unified_person_source_identity") if isinstance(authority, dict) else None + if not isinstance(projection, dict) or not isinstance(source_identity, dict): + return + person_id = _single_line(projection.get("person_id"), 160) + if ( + not person_id + or projection.get("profile_status") != "active" + or projection.get("identity_assurance") not in {"verified", "explicit_linked"} + ): + return + # Stable raw platform identifiers can vary in grammar and may be more + # sensitive than needed in the P4 ledger. Hashing still ties retries + # to the exact _event_message_id(event) source without storing prose. + source_digest = hashlib.sha256(message_id.encode("utf-8", errors="ignore")).hexdigest() + try: + raw_text = getattr(event, "message_str", "") + except Exception as exc: + logger.debug( + "[PrivateCompanion] P4 shadow observer skipped after message-text error: %s", + _single_line(exc, 160), + ) + return + raw_text = raw_text if isinstance(raw_text, str) else "" + shadow_event = { + "event_id": f"p4.normal:{source_digest}", + "occurred_at": occurred_at, + "kind": "normal", + "firewall_safe": True, + "is_command": raw_text.lstrip().startswith("/"), + "is_empty": not bool(raw_text.strip()), + } + operation_id = f"p4.shadow.normal:{person_id}:{source_digest}" + try: + result = self._apply_unified_person_lifecycle( + "record_p4_shadow_event", + person_id, + shadow_event, + operation_id=operation_id, + actor_id="p4_shadow_observer", + ) + except Exception as exc: + logger.debug( + "[PrivateCompanion] P4 shadow observer skipped after persistence error: %s", + _single_line(exc, 160), + ) + return + if not isinstance(result, dict) or not result.get("ok"): + logger.debug( + "[PrivateCompanion] P4 shadow observer rejected event: code=%s", + _single_line(result.get("code") if isinstance(result, dict) else "", 120) or "unknown", + ) + @filter.on_llm_response() async def normalize_tts_enhancement_response(self, event: AstrMessageEvent, resp: LLMResponse, *args, **kwargs): """恢复降级为正文的生图调用,并规范化 TTS 标签。""" diff --git a/memory_companion_adapter.py b/memory_companion_adapter.py index d440434..e8e6d72 100644 --- a/memory_companion_adapter.py +++ b/memory_companion_adapter.py @@ -15,6 +15,7 @@ from .helpers import _missing_optional_model_dependency, _safe_float, _safe_int, from .bot_personal_dto import PrivacyRejected, build_bot_personal_dto from .bot_personal_outbox import due_outbox, enqueue_outbox, update_outbox from .unified_person_contract import build_identity_key, resolve_identity +from .context_orchestration import ATTRIBUTE_NAME, project_context_state, read_context_state def _media_file_name(value: Any, limit: int = 120) -> str: @@ -258,6 +259,17 @@ class MemoryCompanionAdapterMixin: except Exception: return "", 0.0 + def _memory_companion_context_orchestration(self, event: Any | None) -> dict[str, Any] | None: + raw_state = getattr(event, ATTRIBUTE_NAME, None) if event is not None else None + if raw_state is None: + return None + state = read_context_state(event=event) + if state is None or state.get("phase") != "companion_ready": + return {} + if not {"persona", "runtime", "person", "scene"}.issubset(set(state.get("completed_layers", []))): + return {} + return state + def _memory_companion_build_private_context( self, *, @@ -759,12 +771,21 @@ class MemoryCompanionAdapterMixin: "strict_session_only": bool(strict_session_only), "topic_fit_policy": "旧话题和未完成话头只作可选参考;和当前问题不贴时先放着,不必为了兑现它改变本轮话题。", } - session_context.update( - self._memory_companion_unified_person_authority( - event, - expected_user_id=session_context.get("user_id", ""), - ) + authority = self._memory_companion_unified_person_authority( + event, + expected_user_id=session_context.get("user_id", ""), ) + if event is not None: + orchestration = self._memory_companion_context_orchestration(event) + if orchestration == {}: + return "" + if orchestration is None: + if authority: + return "" + session_context["strict_session_only"] = True + else: + session_context["context_orchestration"] = project_context_state(orchestration) + session_context.update(authority) try: bot_mood, bot_energy = self._memory_companion_bot_emotional_state() configured_timeout = max(0.2, min(6.0, _memory_companion_safe_float(getattr(self, "memory_companion_context_timeout_seconds", 1.2), 1.2, 0.2))) diff --git a/p4_affinity_confinement.py b/p4_affinity_confinement.py new file mode 100644 index 0000000..514cf7b --- /dev/null +++ b/p4_affinity_confinement.py @@ -0,0 +1,963 @@ +# -*- coding: utf-8 -*- +"""Pure, deterministic P4-A affinity and confinement shadow engine. + +This module deliberately has no AstrBot, persistence, clock, or I/O dependency. +It is a small reference implementation for the registry-mediated shadow ledger. +All public functions return newly allocated JSON-compatible dictionaries and never +mutate their inputs. + +Public API +========== +``new_shadow_state()`` + Return an empty P4-A shadow state. +``validate_review_result(review)`` + Strictly validate a non-executable review result. It rejects unknown and + executable fields (for example ``severity_steps`` and ``confinement_days``). +``evaluate_violation_policy(review, *, policy_version=POLICY_VERSION)`` + Apply the deterministic, versioned 0/1/2/3-step policy to safe evidence. +``settle_shadow_event(state, event, *, now=None)`` + Settle one event against a copied state. ``now`` is only an explicit, + deterministic timestamp fallback when an event deliberately omits + ``occurred_at``. +``replay_shadow_events(events, *, initial_state=None)`` + Deterministically replay a sequence (chronologically, then by event id). + +The shadow event kinds are ``normal``, ``positive``, ``violation``, +``confinement_expiry``, ``owner_release``, and ``misjudgment``. Every useful +event supplies a stable ``event_id`` and a timezone-aware ``occurred_at``. +``policy_version`` defaults to :data:`POLICY_VERSION`; an explicit unsupported +version is safely recorded as a no-enforcement result. +""" +from __future__ import annotations + +from copy import deepcopy +from datetime import datetime, timedelta, timezone +from decimal import Decimal, InvalidOperation, ROUND_HALF_UP +from math import isfinite +import re +from typing import Any + + +SHADOW_SCHEMA_VERSION = "p4.affinity_confinement.shadow.v1" +REVIEW_SCHEMA_VERSION = "p4.review.v1" +POLICY_VERSION = "p4.violation_policy.v1" +CONFIDENCE_THRESHOLD = 0.90 + +_UTC = timezone.utc +_RECOVERY_INTERVAL = timedelta(days=3) +_ROLLING_WINDOW = timedelta(days=7) +_EVENT_ID_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:@/+-]{0,127}\Z") + +_REVIEW_REQUIRED = frozenset({ + "schema_version", "verdict", "category", "confidence", "risk_flags", +}) +_REVIEW_ALLOWED = frozenset({ + "schema_version", "verdict", "category", "confidence", "risk_flags", + "evidence", "evidence_message_ids", "target", "execution_request", + "persistence", "responsibility", "advisory_risk", "reason_codes", +}) +_FORBIDDEN_REVIEW_FIELDS = frozenset({ + "severity_steps", "penalty_steps", "score_delta", "score_deltas", "delta", + "days", "confinement_days", "minimum_confinement_days", "ban_duration", + "penalty", "warning", "warning_text", "response_text", "reply", + "user_visible_wording", "message", "reason", "explanation", "verdict_text", +}) +_VERDICTS = frozenset({"violation", "no_violation", "uncertain"}) +_TARGETS = frozenset({"bot", "current_person", "system_boundary", "other_user", "unknown"}) +_EXECUTION_REQUESTS = frozenset({ + "none", "system_override", "persona_override", "policy_override", + "tool_execution", "data_access", +}) +_PERSISTENCE = frozenset({"none", "single", "repeated", "sustained"}) +_RESPONSIBILITY = frozenset({"sender", "third_party", "mixed", "unknown"}) +_ADVISORY_RISKS = frozenset({"none", "low", "medium", "high", "critical"}) +_REASON_CODES = frozenset({ + "directed_at_target", "not_quote", "not_roleplay", "bounded_context", + "repeated_pattern", "tool_scope_request", "privacy_scope_request", +}) +_EVIDENCE_CODES = frozenset({ + "message_reference", "direct_instruction_override", "persona_override", + "policy_bypass_request", "credential_request", "cross_user_data_request", + "owner_impersonation", "doxxing_indicator", "real_world_threat_indicator", + "destructive_tool_request", "harassment_targeting", + "sexual_harassment_targeting", "contextual_repeat", +}) +_EVIDENCE_SOURCES = frozenset({"current_message", "reply_context", "bot_context"}) +_RISK_FLAGS = frozenset({ + "persistent_bypass", "owner_impersonation", "cross_user_privacy", + "tool_overreach", "data_exfiltration", "doxxing", "real_world_threat", + "destructive_action", +}) +_POSITIVE_CATEGORIES = frozenset({ + "genuine_care", "reliable_help", "boundary_respect", "sustained_support", + "kept_commitment", +}) +_EVENT_KINDS = frozenset({ + "normal", "positive", "violation", "confinement_expiry", "owner_release", + "misjudgment", +}) + +# The values are (maximum deterministic step count, category minimum duration). +_CATEGORY_POLICY: dict[str, tuple[int, int]] = { + "prompt_injection": (1, 0), + "persona_override": (1, 0), + "policy_bypass": (1, 0), + "boundary_harassment": (1, 0), + "sexual_harassment": (1, 0), + "owner_impersonation": (2, 3), + "cross_user_privacy": (2, 3), + "tool_overreach": (2, 3), + "doxxing": (3, 9), + "real_world_threat": (3, 9), + "destructive_action": (3, 9), +} +_MODERATE_FLAGS = frozenset({ + "owner_impersonation", "cross_user_privacy", "tool_overreach", "data_exfiltration", +}) +_CRITICAL_FLAGS = frozenset({"doxxing", "real_world_threat", "destructive_action"}) + + +def new_shadow_state() -> dict[str, Any]: + """Return a new, serializable P4-A shadow-only state. + + ``event_log`` is deliberately retained for deterministic owner misjudgment + replay. A registry may persist it as an append-only shadow ledger. + """ + return { + "schema_version": SHADOW_SCHEMA_VERSION, + "mode": "shadow", + "policy_version": POLICY_VERSION, + "score": 0, + "warning_stage": "none", + "confinement_state": "none", + "confinement_round": 0, + "confinement_until": "", + "confinement_duration_days": 0, + "release_prompt_pending": False, + "negative_recovery_anchor": "", + "recovery_elapsed_carry_seconds": 0, + "pending_recovery_steps": 0, + "processed_event_ids": [], + "revoked_event_ids": [], + "positive_ledger": [], + "event_log": [], + } + + +def validate_review_result(review: Any) -> dict[str, Any]: + """Validate and normalize a non-executable violation-review result. + + Valid output is intentionally limited to enums, bounded confidence, stable + message references, and evidence codes. Free-form explanations and any + field which can directly decide a penalty, duration, or user-visible reply + are rejected. The returned ``review`` is safe to put in a shadow ledger. + """ + errors: list[str] = [] + if not isinstance(review, dict): + return {"valid": False, "errors": ["review_not_object"], "review": None} + if _contains_forbidden_review_field(review): + return {"valid": False, "errors": ["executable_review_field"], "review": None} + unknown = sorted(str(key) for key in review if key not in _REVIEW_ALLOWED) + if unknown: + return {"valid": False, "errors": ["unknown_review_field"], "review": None} + missing = sorted(_REVIEW_REQUIRED.difference(review)) + if missing: + return {"valid": False, "errors": ["missing_review_field"], "review": None} + if "evidence" in review and "evidence_message_ids" in review: + return {"valid": False, "errors": ["ambiguous_evidence"], "review": None} + + if review.get("schema_version") != REVIEW_SCHEMA_VERSION: + errors.append("review_schema_version_invalid") + verdict = review.get("verdict") + if verdict not in _VERDICTS: + errors.append("review_verdict_invalid") + category = review.get("category") + allowed_category = set(_CATEGORY_POLICY) | {"none"} + if not isinstance(category, str) or category not in allowed_category: + errors.append("review_category_invalid") + confidence = _finite_number(review.get("confidence")) + if confidence is None or not 0.0 <= confidence <= 1.0: + errors.append("review_confidence_invalid") + risk_flags = _safe_enum_list(review.get("risk_flags"), _RISK_FLAGS) + if risk_flags is None: + errors.append("review_risk_flags_invalid") + risk_flags = [] + evidence = _normalize_evidence(review, errors) + + optional_enums = { + "target": _TARGETS, + "execution_request": _EXECUTION_REQUESTS, + "persistence": _PERSISTENCE, + "responsibility": _RESPONSIBILITY, + "advisory_risk": _ADVISORY_RISKS, + } + normalized: dict[str, Any] = { + "schema_version": REVIEW_SCHEMA_VERSION, + "verdict": verdict if isinstance(verdict, str) else "", + "category": category if isinstance(category, str) else "", + "confidence": confidence if confidence is not None else 0.0, + "risk_flags": risk_flags, + "evidence": evidence, + } + for field, allowed in optional_enums.items(): + if field not in review: + continue + value = review.get(field) + if value not in allowed: + errors.append(f"review_{field}_invalid") + else: + normalized[field] = value + if "reason_codes" in review: + reason_codes = _safe_enum_list(review.get("reason_codes"), _REASON_CODES) + if reason_codes is None: + errors.append("review_reason_codes_invalid") + else: + normalized["reason_codes"] = reason_codes + + if verdict == "violation" and not evidence: + errors.append("violation_evidence_required") + if verdict == "violation" and category == "none": + errors.append("violation_category_required") + if errors: + return {"valid": False, "errors": sorted(set(errors)), "review": None} + return {"valid": True, "errors": [], "review": normalized} + + +def evaluate_violation_policy( + review: Any, + *, + policy_version: str = POLICY_VERSION, +) -> dict[str, Any]: + """Return a deterministic 0/1/2/3-step policy decision. + + The model never supplies a step count. Only a validated verdict, category, + confidence, evidence and bounded risk factors are considered. ``advisory`` + model fields are retained for audit but deliberately have no effect here. + """ + validation = validate_review_result(review) + decision: dict[str, Any] = { + "policy_version": policy_version, + "accepted": bool(validation["valid"]), + "steps": 0, + "minimum_confinement_days": 0, + "minimum_confinement_tier": 0, + "reason_codes": [], + "review": validation["review"], + } + if policy_version != POLICY_VERSION: + decision["accepted"] = False + decision["reason_codes"] = ["policy_version_unsupported"] + return decision + if not validation["valid"]: + decision["reason_codes"] = list(validation["errors"]) + return decision + normalized = validation["review"] + assert isinstance(normalized, dict) + if normalized["verdict"] != "violation": + decision["reason_codes"] = ["review_not_violation"] + return decision + if normalized["confidence"] < CONFIDENCE_THRESHOLD: + decision["reason_codes"] = ["review_confidence_below_threshold"] + return decision + if not normalized["evidence"]: + decision["reason_codes"] = ["violation_evidence_required"] + return decision + + steps, minimum_days = _CATEGORY_POLICY.get(normalized["category"], (0, 0)) + risk_flags = set(normalized["risk_flags"]) + persistence = normalized.get("persistence", "single") + if persistence == "sustained" or "persistent_bypass" in risk_flags: + steps = max(steps, 2) + if risk_flags.intersection(_MODERATE_FLAGS): + steps = max(steps, 2) + minimum_days = max(minimum_days, 3) + if risk_flags.intersection(_CRITICAL_FLAGS): + steps = 3 + minimum_days = max(minimum_days, 9) + decision["steps"] = min(3, max(0, steps)) + decision["minimum_confinement_days"] = minimum_days + decision["minimum_confinement_tier"] = minimum_days + decision["reason_codes"] = ["policy_settled"] if steps else ["category_not_actionable"] + return decision + + +def settle_shadow_event( + state: Any, + event: Any, + *, + now: Any | None = None, +) -> dict[str, Any]: + """Settle one event without mutating ``state`` or ``event``. + + ``event`` must contain a stable ``event_id``, a timezone-aware + ``occurred_at`` (or the explicit ``now`` fallback), and one of the documented + event kinds. The returned ``details`` contains only stable codes and numeric + audit facts; it never contains message content or model prose. + """ + working = _normalize_state(state) + record, event_errors = _normalize_event(event, now=now) + if record is None: + return _settlement_result(working, "invalid_event", "", False, {"codes": event_errors}) + event_id = record["event_id"] + if event_id in working["processed_event_ids"]: + return _settlement_result(working, "idempotent", event_id, False, {"codes": ["event_already_processed"]}) + + when = _parse_time(record["occurred_at"]) + assert when is not None + expired = _expire_if_due(working, when) + if record["policy_version"] != POLICY_VERSION: + _append_record(working, record) + return _settlement_result( + working, + "policy_version_unsupported", + event_id, + expired, + {"codes": ["policy_version_unsupported"], "expired": expired}, + ) + + kind = record["kind"] + if kind == "normal": + outcome, applied, details = _settle_normal(working, record, when, expired) + elif kind == "positive": + outcome, applied, details = _settle_positive(working, record, when) + elif kind == "violation": + outcome, applied, details = _settle_violation(working, record, when) + elif kind == "confinement_expiry": + outcome = "confinement_expired" if expired else "confinement_not_due" + applied = expired + details = {"codes": [outcome]} + elif kind == "owner_release": + outcome, applied, details = _settle_owner_release(working, record, when) + elif kind == "misjudgment": + return _settle_misjudgment(working, record, expired) + else: + outcome, applied, details = "invalid_event_kind", False, {"codes": event_errors or ["event_kind_invalid"]} + + _append_record(working, record) + return _settlement_result(working, outcome, event_id, applied, details) + + +def replay_shadow_events( + events: Any, + *, + initial_state: Any | None = None, +) -> dict[str, Any]: + """Replay events in canonical chronological/event-id order. + + This is intentionally a pure replay helper. It is suitable for a registry + to compare a stored shadow projection with its append-only ledger. + """ + state = _normalize_state(initial_state) if initial_state is not None else new_shadow_state() + if not isinstance(events, list): + return {"state": state, "settlements": [{"outcome": "invalid_event_sequence"}]} + ordered = sorted(enumerate(events), key=_event_sort_key) + settlements: list[dict[str, Any]] = [] + for _, event in ordered: + result = settle_shadow_event(state, event) + state = result["state"] + settlements.append({ + "event_id": result["event_id"], + "outcome": result["outcome"], + "applied": result["applied"], + }) + return {"state": state, "settlements": settlements} + + +# Compact aliases make the pure engine convenient for a registry without adding +# a second semantic surface. +validate_review = validate_review_result +evaluate_policy = evaluate_violation_policy +settle_event = settle_shadow_event +replay_events = replay_shadow_events + + +def _contains_forbidden_review_field(value: Any) -> bool: + if isinstance(value, dict): + for key, child in value.items(): + if not isinstance(key, str) or key.strip().lower() in _FORBIDDEN_REVIEW_FIELDS: + return True + if _contains_forbidden_review_field(child): + return True + elif isinstance(value, list): + return any(_contains_forbidden_review_field(item) for item in value) + return False + + +def _safe_enum_list(value: Any, allowed: frozenset[str]) -> list[str] | None: + if not isinstance(value, list) or any(not isinstance(item, str) or item not in allowed for item in value): + return None + if len(set(value)) != len(value): + return None + return sorted(value) + + +def _normalize_evidence(review: dict[str, Any], errors: list[str]) -> list[dict[str, str]]: + raw = review.get("evidence", review.get("evidence_message_ids", [])) + if not isinstance(raw, list): + errors.append("review_evidence_invalid") + return [] + result: list[dict[str, str]] = [] + for item in raw: + if isinstance(item, str): + message_id = _safe_identifier(item) + code, source = "message_reference", "current_message" + elif isinstance(item, dict): + if not set(item).issubset({"message_id", "code", "source"}): + errors.append("review_evidence_invalid") + continue + message_id = _safe_identifier(item.get("message_id")) + code = item.get("code", "message_reference") + source = item.get("source", "current_message") + else: + message_id, code, source = None, "", "" + if message_id is None or code not in _EVIDENCE_CODES or source not in _EVIDENCE_SOURCES: + errors.append("review_evidence_invalid") + continue + normalized = {"message_id": message_id, "code": code, "source": source} + if normalized not in result: + result.append(normalized) + return result + + +def _safe_identifier(value: Any) -> str | None: + if not isinstance(value, str): + return None + text = value.strip() + return text if _EVENT_ID_RE.fullmatch(text) else None + + +def _finite_number(value: Any) -> float | None: + if isinstance(value, bool) or not isinstance(value, (int, float)): + return None + number = float(value) + return number if isfinite(number) else None + + +def _parse_time(value: Any) -> datetime | None: + if isinstance(value, datetime): + moment = value + elif isinstance(value, str) and value.strip(): + text = value.strip() + if text.endswith("Z"): + text = f"{text[:-1]}+00:00" + try: + moment = datetime.fromisoformat(text) + except ValueError: + return None + else: + return None + if moment.tzinfo is None or moment.utcoffset() is None: + return None + return moment.astimezone(_UTC) + + +def _format_time(moment: datetime) -> str: + normalized = moment.astimezone(_UTC) + timespec = "microseconds" if normalized.microsecond else "seconds" + return normalized.isoformat(timespec=timespec).replace("+00:00", "Z") + + +def _normalize_state(value: Any) -> dict[str, Any]: + base = new_shadow_state() + if not isinstance(value, dict): + return base + raw_score = value.get("score", value.get("affinity_score", 0)) + score = _finite_number(raw_score) + base["score"] = max(-1200, min(1200, int(score or 0))) + if base["score"] < 0 and base["score"] not in {-400, -800, -1200}: + # Persisted legacy values are safely clamped into the nearest strict band. + base["score"] = -400 if base["score"] > -600 else (-800 if base["score"] > -1000 else -1200) + round_value = _finite_number(value.get("confinement_round")) + base["confinement_round"] = max(0, int(round_value or 0)) + duration = _finite_number(value.get("confinement_duration_days")) + base["confinement_duration_days"] = max(0, int(duration or 0)) + until = _parse_time(value.get("confinement_until")) + base["confinement_until"] = _format_time(until) if until else "" + anchor = _parse_time(value.get("negative_recovery_anchor")) + base["negative_recovery_anchor"] = _format_time(anchor) if anchor else "" + carry = _finite_number(value.get("recovery_elapsed_carry_seconds")) + base["recovery_elapsed_carry_seconds"] = max(0, int(carry or 0)) + base["release_prompt_pending"] = value.get("release_prompt_pending") is True + state_value = value.get("confinement_state") + if base["score"] == -1200 and state_value == "active" and until: + base["confinement_state"] = "active" + elif base["score"] < 0 and state_value == "released": + base["confinement_state"] = "released" + _sync_warning_stage(base) + if base["score"] >= 0: + base["confinement_state"] = "none" + base["confinement_until"] = "" + base["confinement_duration_days"] = 0 + base["release_prompt_pending"] = False + base["negative_recovery_anchor"] = "" + base["recovery_elapsed_carry_seconds"] = 0 + base["processed_event_ids"] = _unique_identifiers(value.get("processed_event_ids")) + base["revoked_event_ids"] = _unique_identifiers(value.get("revoked_event_ids")) + base["positive_ledger"] = _normalize_positive_ledger(value.get("positive_ledger")) + base["event_log"] = _normalize_event_log(value.get("event_log")) + _refresh_recovery(base, anchor or datetime(1970, 1, 1, tzinfo=_UTC)) + return base + + +def _unique_identifiers(value: Any) -> list[str]: + if not isinstance(value, list): + return [] + result: list[str] = [] + for item in value: + identifier = _safe_identifier(item) + if identifier and identifier not in result: + result.append(identifier) + return result + + +def _normalize_positive_ledger(value: Any) -> list[dict[str, Any]]: + if not isinstance(value, list): + return [] + result: list[dict[str, Any]] = [] + for item in value: + if not isinstance(item, dict): + continue + event_id = _safe_identifier(item.get("event_id")) + occurred = _parse_time(item.get("occurred_at")) + delta = _finite_number(item.get("delta")) + if event_id is None or occurred is None or delta is None or not 0 <= int(delta) <= 4: + continue + result.append({"event_id": event_id, "occurred_at": _format_time(occurred), "delta": int(delta)}) + return result + + +def _normalize_event_log(value: Any) -> list[dict[str, Any]]: + if not isinstance(value, list): + return [] + return [deepcopy(item) for item in value if isinstance(item, dict) and _safe_identifier(item.get("event_id"))] + + +def _sync_warning_stage(state: dict[str, Any]) -> None: + score = state["score"] + state["warning_stage"] = ( + "confinement" if score <= -1200 else + "warning_2" if score == -800 else + "warning_1" if score == -400 else + "none" + ) + + +def _refresh_recovery(state: dict[str, Any], now: datetime) -> None: + if state["score"] not in {-400, -800}: + state["pending_recovery_steps"] = 0 + state["recovery_elapsed_carry_seconds"] = 0 + return + anchor = _parse_time(state.get("negative_recovery_anchor")) + if anchor is None or now < anchor: + state["pending_recovery_steps"] = 0 + state["recovery_elapsed_carry_seconds"] = 0 + return + elapsed_seconds = int((now - anchor).total_seconds()) + interval_seconds = int(_RECOVERY_INTERVAL.total_seconds()) + elapsed_steps, carry = divmod(elapsed_seconds, interval_seconds) + needed = 2 if state["score"] == -800 else 1 + state["pending_recovery_steps"] = min(elapsed_steps, needed) + state["recovery_elapsed_carry_seconds"] = carry + + +def _expire_if_due(state: dict[str, Any], now: datetime) -> bool: + until = _parse_time(state.get("confinement_until")) + if state.get("confinement_state") != "active" or until is None or now < until: + return False + state["score"] = -800 + _sync_warning_stage(state) + state["confinement_state"] = "released" + state["confinement_until"] = "" + state["confinement_duration_days"] = 0 + state["release_prompt_pending"] = True + state["negative_recovery_anchor"] = _format_time(until) + _refresh_recovery(state, now) + return True + + +def _normalize_event(event: Any, *, now: Any | None) -> tuple[dict[str, Any] | None, list[str]]: + if not isinstance(event, dict): + return None, ["event_not_object"] + event_id = _safe_identifier(event.get("event_id")) + when = _parse_time(event.get("occurred_at")) or _parse_time(now) + if event_id is None: + return None, ["event_id_invalid"] + if when is None: + return None, ["event_time_invalid"] + kind = event.get("kind") + policy_version = event.get("policy_version", POLICY_VERSION) + if not isinstance(policy_version, str) or len(policy_version) > 80: + policy_version = "" + record: dict[str, Any] = { + "event_id": event_id, + "occurred_at": _format_time(when), + "kind": kind if kind in _EVENT_KINDS else "invalid", + "policy_version": policy_version, + "is_owner": event.get("is_owner") is True, + } + errors: list[str] = [] + if record["kind"] == "invalid": + errors.append("event_kind_invalid") + if record["kind"] == "normal": + record["recovery_eligible"] = ( + event.get("firewall_safe", True) is True + and event.get("is_command") is not True + and event.get("is_tool_call") is not True + and event.get("is_empty") is not True + ) + elif record["kind"] == "positive": + _normalize_positive_payload(event, record, errors) + elif record["kind"] == "violation": + raw_review = event.get("review", event.get("review_result")) + validation = validate_review_result(raw_review) + record["review"] = validation["review"] + record["review_errors"] = list(validation["errors"]) + elif record["kind"] in {"owner_release", "misjudgment"}: + record["actor_is_owner"] = ( + event.get("actor_is_owner") is True or event.get("owner_authorized") is True + ) + if record["kind"] == "misjudgment": + has_canonical_target = "revoke_event_id" in event + has_legacy_target = "event_to_revoke" in event + if has_canonical_target and has_legacy_target: + errors.append("revoke_event_id_ambiguous") + elif has_canonical_target or has_legacy_target: + target = _safe_identifier( + event.get("revoke_event_id") if has_canonical_target else event.get("event_to_revoke") + ) + if target is None: + errors.append("revoke_event_id_invalid") + else: + record["revoke_event_id"] = target + if errors: + record["payload_errors"] = sorted(set(errors)) + return record, errors + + +def _normalize_positive_payload(event: dict[str, Any], record: dict[str, Any], errors: list[str]) -> None: + if any(key in event for key in ("score_delta", "delta", "points", "severity_steps", "days")): + errors.append("positive_executable_field") + return + category = event.get("positive_category") + if category not in _POSITIVE_CATEGORIES: + errors.append("positive_category_invalid") + return + base_points = event.get("base_points", 4) + if isinstance(base_points, bool) or not isinstance(base_points, int) or not 1 <= base_points <= 4: + errors.append("positive_base_points_invalid") + return + factors: dict[str, float] = {} + for field in ("quality", "reciprocity", "novelty"): + number = _finite_number(event.get(field, 1.0)) + if number is None or not 0.0 <= number <= 1.0: + errors.append(f"positive_{field}_invalid") + else: + factors[field] = number + is_group = event.get("is_group") is True + percent = event.get("group_affinity_weight_percent", 100) + if is_group and "group_affinity_weight_percent" not in event: + errors.append("group_affinity_weight_required") + if isinstance(percent, bool) or not isinstance(percent, int) or not 0 <= percent <= 100: + errors.append("group_affinity_weight_invalid") + if errors: + return + record.update({ + "positive_category": category, + "base_points": base_points, + "quality": factors["quality"], + "reciprocity": factors["reciprocity"], + "novelty": factors["novelty"], + "is_group": is_group, + "group_affinity_weight_percent": percent, + }) + + +def _settle_normal( + state: dict[str, Any], + record: dict[str, Any], + when: datetime, + expired: bool, +) -> tuple[str, bool, dict[str, Any]]: + if record["is_owner"]: + return "owner_automatic_exempt", False, {"codes": ["owner_automatic_exempt"]} + if state["confinement_state"] == "active": + return "confinement_active", False, {"codes": ["confinement_active"]} + if not record.get("recovery_eligible"): + return "normal_no_settlement", False, {"codes": ["normal_not_recovery_eligible"]} + _refresh_recovery(state, when) + if state["release_prompt_pending"]: + state["release_prompt_pending"] = False + return "release_prompt_only", expired, {"codes": ["release_prompt_only"]} + steps = state["pending_recovery_steps"] + if steps <= 0: + return "normal_no_settlement", False, {"codes": ["normal_no_auto_affinity"]} + from_score = state["score"] + if from_score == -800: + to_score = 0 if steps >= 2 else -400 + else: + to_score = 0 + steps = 1 + anchor = _parse_time(state["negative_recovery_anchor"]) + assert anchor is not None + state["score"] = to_score + _sync_warning_stage(state) + if to_score == 0: + state["confinement_state"] = "none" + state["confinement_round"] = 0 + state["confinement_until"] = "" + state["confinement_duration_days"] = 0 + state["negative_recovery_anchor"] = "" + state["pending_recovery_steps"] = 0 + state["recovery_elapsed_carry_seconds"] = 0 + else: + state["confinement_state"] = "released" + state["negative_recovery_anchor"] = _format_time(anchor + _RECOVERY_INTERVAL * steps) + _refresh_recovery(state, when) + return "recovery_settled", True, { + "codes": ["recovery_settled"], + "from_score": from_score, + "to_score": to_score, + "applied_steps": steps, + } + + +def _settle_positive(state: dict[str, Any], record: dict[str, Any], when: datetime) -> tuple[str, bool, dict[str, Any]]: + if record["is_owner"]: + return "owner_automatic_exempt", False, {"codes": ["owner_automatic_exempt"]} + if record.get("payload_errors"): + return "positive_rejected", False, {"codes": record["payload_errors"]} + if state["score"] < 0: + return "positive_blocked_negative", False, {"codes": ["negative_score_blocks_positive"]} + raw = ( + Decimal(record["base_points"]) + * Decimal(str(record["quality"])) + * Decimal(str(record["reciprocity"])) + * Decimal(str(record["novelty"])) + * Decimal(record["group_affinity_weight_percent"]) / Decimal(100) + * _diminishing_factor(state["score"]) + ) + proposed = min(4, max(0, int(raw.quantize(Decimal("1"), rounding=ROUND_HALF_UP)))) + daily = sum( + entry["delta"] + for entry in state["positive_ledger"] + if _parse_time(entry["occurred_at"]).date() == when.date() + ) + rolling = sum( + entry["delta"] + for entry in state["positive_ledger"] + if when - _ROLLING_WINDOW < _parse_time(entry["occurred_at"]) <= when + ) + applied_delta = min(proposed, max(0, 8 - daily), max(0, 30 - rolling), max(0, 1200 - state["score"])) + state["positive_ledger"].append({ + "event_id": record["event_id"], "occurred_at": record["occurred_at"], "delta": applied_delta, + }) + if applied_delta: + state["score"] += applied_delta + _sync_warning_stage(state) + return ( + "positive_settled" if applied_delta else "positive_capped", + bool(applied_delta), + {"codes": ["positive_settled" if applied_delta else "positive_cap_reached"], "delta": applied_delta}, + ) + + +def _diminishing_factor(score: int) -> Decimal: + if score <= 0: + return Decimal(1) + # Decimal keeps rounding deterministic while float power is sufficient for a + # bounded, non-security-affecting positive-affinity attenuation factor. + return Decimal(str((1.0 - min(score, 1200) / 1200.0) ** 1.6)) + + +def _settle_violation(state: dict[str, Any], record: dict[str, Any], when: datetime) -> tuple[str, bool, dict[str, Any]]: + if record["is_owner"]: + return "owner_automatic_exempt", False, {"codes": ["owner_automatic_exempt"]} + decision = evaluate_violation_policy(record.get("review"), policy_version=record["policy_version"]) + record["policy_decision"] = { + "policy_version": decision["policy_version"], + "steps": decision["steps"], + "minimum_confinement_days": decision["minimum_confinement_days"], + "reason_codes": decision["reason_codes"], + } + steps = decision["steps"] + if steps <= 0: + return "violation_no_penalty", False, {"codes": decision["reason_codes"], "steps": 0} + if state["confinement_state"] == "active": + return "confinement_active", False, {"codes": ["confinement_active"], "steps": steps} + old_score = state["score"] + stage = 0 if old_score >= 0 else (1 if old_score == -400 else 2 if old_score == -800 else 3) + target_stage = min(3, stage + steps) + if target_stage >= 3: + _enter_confinement(state, when, decision["minimum_confinement_days"]) + return "violation_confinement", True, { + "codes": ["violation_confinement"], "steps": steps, + "minimum_confinement_days": decision["minimum_confinement_days"], + } + state["score"] = -400 if target_stage == 1 else -800 + _sync_warning_stage(state) + state["confinement_state"] = "none" + state["confinement_until"] = "" + state["confinement_duration_days"] = 0 + state["release_prompt_pending"] = False + state["negative_recovery_anchor"] = _format_time(when) + _refresh_recovery(state, when) + return "violation_warning", True, {"codes": ["violation_warning"], "steps": steps, "from_score": old_score, "to_score": state["score"]} + + +def _enter_confinement(state: dict[str, Any], when: datetime, minimum_days: int) -> None: + state["score"] = -1200 + _sync_warning_stage(state) + state["confinement_round"] = max(1, state["confinement_round"] + 1) + round_days = 1 if state["confinement_round"] == 1 else 3 if state["confinement_round"] == 2 else 9 + duration = max(round_days, minimum_days) + state["confinement_state"] = "active" + state["confinement_duration_days"] = duration + state["confinement_until"] = _format_time(when + timedelta(days=duration)) + state["release_prompt_pending"] = False + state["negative_recovery_anchor"] = "" + state["pending_recovery_steps"] = 0 + state["recovery_elapsed_carry_seconds"] = 0 + + +def _settle_owner_release(state: dict[str, Any], record: dict[str, Any], when: datetime) -> tuple[str, bool, dict[str, Any]]: + if not record.get("actor_is_owner"): + return "owner_required", False, {"codes": ["owner_required"]} + # Releasing is an exemption from an existing confinement, never an + # independent state transition that can manufacture a negative score. + # In particular, an owner command aimed at a healthy, warned, expired, or + # already-released person is advisory/no-op in P4-A and must remain so when + # P4-B eventually enables the command. + if state.get("confinement_state") != "active" or state.get("score") != -1200: + return "owner_release_not_confined", False, {"codes": ["owner_release_not_confined"]} + state["score"] = -800 + _sync_warning_stage(state) + state["confinement_state"] = "released" + state["confinement_until"] = "" + state["confinement_duration_days"] = 0 + # A manual release follows the same one-turn release-message boundary as a + # natural expiry. The caller remains shadow-only in P4-A, but the derived + # state must already model the P4-B behavior faithfully. + state["release_prompt_pending"] = True + state["negative_recovery_anchor"] = _format_time(when) + _refresh_recovery(state, when) + return "owner_release_settled", True, {"codes": ["owner_release_settled"]} + + +def _settle_misjudgment(state: dict[str, Any], record: dict[str, Any], expired: bool) -> dict[str, Any]: + event_id = record["event_id"] + if not record.get("actor_is_owner"): + _append_record(state, record) + return _settlement_result(state, "owner_required", event_id, expired, {"codes": ["owner_required"]}) + # Only a genuinely omitted target may select the most recent reversible + # violation. A malformed or ambiguous explicit target must never silently + # broaden into that fallback. + if record.get("payload_errors"): + _append_record(state, record) + return _settlement_result( + state, + "misjudgment_rejected", + event_id, + expired, + {"codes": list(record["payload_errors"])}, + ) + target = record.get("revoke_event_id") + history = list(state["event_log"]) + history_by_id = { + item.get("event_id"): item + for item in history + if isinstance(item, dict) and isinstance(item.get("event_id"), str) + } + + def is_reversible_violation(item: Any) -> bool: + if not isinstance(item, dict) or item.get("kind") != "violation": + return False + decision = evaluate_violation_policy( + item.get("review"), + policy_version=str(item.get("policy_version") or POLICY_VERSION), + ) + return int(decision.get("steps") or 0) > 0 + + if target is None: + ordered = sorted(enumerate(history), key=_event_sort_key) + target = next( + ( + item.get("event_id") + for _, item in reversed(ordered) + if is_reversible_violation(item) + and item.get("event_id") not in state["revoked_event_ids"] + ), + None, + ) + if isinstance(target, str): + # Persist the selected target so a later replay never depends on a + # changing definition of "most recent". + record["revoke_event_id"] = target + target_record = history_by_id.get(target) if isinstance(target, str) else None + if not isinstance(target, str) or target_record is None or target == event_id: + _append_record(state, record) + return _settlement_result(state, "revoke_target_unknown", event_id, expired, {"codes": ["revoke_target_unknown"]}) + if not is_reversible_violation(target_record): + _append_record(state, record) + return _settlement_result(state, "revoke_target_not_violation", event_id, expired, {"codes": ["revoke_target_not_violation"]}) + if target in state["revoked_event_ids"]: + _append_record(state, record) + return _settlement_result(state, "revoke_target_already_revoked", event_id, expired, {"codes": ["revoke_target_already_revoked"]}) + revoked = sorted(set(state["revoked_event_ids"]) | {target}) + rebuilt = _rebuild_from_history(history, revoked) + rebuilt["revoked_event_ids"] = revoked + rebuilt["event_log"] = deepcopy(history) + rebuilt["processed_event_ids"] = _unique_identifiers([item.get("event_id") for item in history] + [event_id]) + _append_record(rebuilt, record) + return _settlement_result( + rebuilt, + "misjudgment_replayed", + event_id, + True, + {"codes": ["misjudgment_replayed"], "revoked_event_id": target}, + ) + + +def _rebuild_from_history(history: list[dict[str, Any]], revoked: list[str]) -> dict[str, Any]: + rebuilt = new_shadow_state() + revoked_set = set(revoked) + for _, record in sorted(enumerate(history), key=_event_sort_key): + event_id = record.get("event_id") + if event_id in revoked_set or record.get("kind") == "misjudgment": + continue + result = settle_shadow_event(rebuilt, record) + rebuilt = result["state"] + return rebuilt + + +def _append_record(state: dict[str, Any], record: dict[str, Any]) -> None: + event_id = record["event_id"] + if event_id not in state["processed_event_ids"]: + state["processed_event_ids"].append(event_id) + if not any(item.get("event_id") == event_id for item in state["event_log"]): + state["event_log"].append(deepcopy(record)) + + +def _settlement_result( + state: dict[str, Any], + outcome: str, + event_id: str, + applied: bool, + details: dict[str, Any], +) -> dict[str, Any]: + return { + "state": state, + "outcome": outcome, + "event_id": event_id, + "applied": bool(applied), + "shadow": True, + "details": deepcopy(details), + } + + +def _event_sort_key(indexed: tuple[int, Any]) -> tuple[datetime, str, int]: + index, event = indexed + if isinstance(event, dict): + when = _parse_time(event.get("occurred_at")) or datetime.max.replace(tzinfo=_UTC) + event_id = _safe_identifier(event.get("event_id")) or "~" + return when, event_id, index + return datetime.max.replace(tzinfo=_UTC), "~", index diff --git a/p4_capabilities.py b/p4_capabilities.py new file mode 100644 index 0000000..a47cfae --- /dev/null +++ b/p4_capabilities.py @@ -0,0 +1,153 @@ +# -*- coding: utf-8 -*- +"""Strict, non-executing capability parsing for P4 management commands. + +This module deliberately contains no AstrBot integration, persistence, owner +lookup, or state transition. It only recognizes a complete, unambiguous +command payload and returns the capability metadata needed by a later security +gate. A prefix match is never sufficient to bypass confinement handling. + +The registry is immutable and P4-A remains shadow/advisory only. Callers must +still apply the P3 gates, resolve the stable target, verify owner authority, +write an audit event, and decide whether any later phase permits execution. +""" +from __future__ import annotations + +from dataclasses import dataclass +import re +from types import MappingProxyType +from typing import Callable, Mapping + + +# Keep this grammar in lockstep with p4_affinity_confinement._EVENT_ID_RE. +# Unlike that internal normalization helper, this command parser never strips +# input: leading, trailing, or token-separating whitespace means no match. +_SAFE_EVENT_ID = r"[A-Za-z0-9][A-Za-z0-9_.:@/+-]{0,127}" +_PERSON_ID = r"person_[0-9a-f]{24}" +_P0_IDENTITY_KEY = r"ops-origin-v1:[0-9a-f]{64}" +_TARGET = rf"(?:{_PERSON_ID}|{_P0_IDENTITY_KEY})" + +PERSON_ID_RE = re.compile(rf"{_PERSON_ID}\Z") +P0_IDENTITY_KEY_RE = re.compile(rf"{_P0_IDENTITY_KEY}\Z") +SAFE_EVENT_ID_RE = re.compile(rf"{_SAFE_EVENT_ID}\Z") + +_RELEASE_RE = re.compile(rf"/放出 (?P{_TARGET})\Z") +_MISJUDGMENT_RE = re.compile( + rf"/误判 (?P{_TARGET})(?: (?P{_SAFE_EVENT_ID}))?\Z" +) + + +@dataclass(frozen=True) +class Capability: + """One exact, non-executing command capability. + + ``parser`` is intentionally exact: it receives the entire raw payload and + returns ``None`` unless every byte belongs to the command grammar. + """ + + capability_id: str + parser: Callable[[str], tuple[str, str | None] | None] + group: str + tool: str + sensitivity: str + requires_owner_authorization: bool + self_service_allowed: bool + execution_mode: str + + +@dataclass(frozen=True) +class ParsedP4ManagementCommand: + """A syntactically valid management intent, never an authorization result.""" + + capability_id: str + target: str + target_kind: str + event_id: str | None + group: str + tool: str + sensitivity: str + requires_owner_authorization: bool + self_service_allowed: bool + execution_mode: str + + +def _parse_release(payload: str) -> tuple[str, str | None] | None: + match = _RELEASE_RE.fullmatch(payload) + if match is None: + return None + return match.group("target"), None + + +def _parse_misjudgment(payload: str) -> tuple[str, str | None] | None: + match = _MISJUDGMENT_RE.fullmatch(payload) + if match is None: + return None + return match.group("target"), match.group("event_id") + + +# A tuple of frozen records makes command registration static. The companion +# runtime may consult this metadata later, but cannot use it as an authority +# decision or a live-effect switch during P4-A. +P4_CAPABILITY_REGISTRY: tuple[Capability, ...] = ( + Capability( + capability_id="p4.owner_release", + parser=_parse_release, + group="p4_affinity_confinement", + tool="owner_release", + sensitivity="owner_only_confinement_exemption", + requires_owner_authorization=True, + self_service_allowed=False, + execution_mode="shadow_advisory_only", + ), + Capability( + capability_id="p4.owner_misjudgment", + parser=_parse_misjudgment, + group="p4_affinity_confinement", + tool="owner_misjudgment", + sensitivity="owner_only_ledger_reversal", + requires_owner_authorization=True, + self_service_allowed=False, + execution_mode="shadow_advisory_only", + ), +) + +P4_CAPABILITY_BY_ID: Mapping[str, Capability] = MappingProxyType( + {capability.capability_id: capability for capability in P4_CAPABILITY_REGISTRY} +) + + +def parse_p4_management_command(payload: object) -> ParsedP4ManagementCommand | None: + """Return a management intent only for a complete pure command payload. + + The function intentionally performs no trimming, Unicode normalization, + nickname lookup, identity resolution, owner check, audit write, or state + transition. In particular, ``/放出`` or ``/误判`` prefixes surrounded by + prose do not match and therefore cannot receive command exemptions. + """ + + if not isinstance(payload, str): + return None + for capability in P4_CAPABILITY_REGISTRY: + parsed = capability.parser(payload) + if parsed is None: + continue + target, event_id = parsed + target_kind = "person_id" if PERSON_ID_RE.fullmatch(target) else "p0_identity_key" + return ParsedP4ManagementCommand( + capability_id=capability.capability_id, + target=target, + target_kind=target_kind, + event_id=event_id, + group=capability.group, + tool=capability.tool, + sensitivity=capability.sensitivity, + requires_owner_authorization=capability.requires_owner_authorization, + self_service_allowed=capability.self_service_allowed, + execution_mode=capability.execution_mode, + ) + return None + + +def is_exact_p4_management_command(payload: object) -> bool: + """Whether ``payload`` is a complete registered P4 command, not an authorization.""" + + return parse_p4_management_command(payload) is not None diff --git a/prompt_surface.py b/prompt_surface.py index 203e294..7eae3f5 100644 --- a/prompt_surface.py +++ b/prompt_surface.py @@ -5,6 +5,7 @@ from dataclasses import dataclass, field from typing import Any, Callable, Iterable from .helpers import _single_line +from .context_orchestration import LAYERS, infer_context_layer @dataclass @@ -13,6 +14,7 @@ class PromptFragment: content: str priority: int = 100 source: str = "" + layer: str = "scene" index: int = 0 metadata: dict[str, Any] = field(default_factory=dict) @@ -34,6 +36,7 @@ class PromptSurface: *, priority: int = 100, source: str = "", + layer: str | None = None, metadata: dict[str, Any] | None = None, ) -> None: text = str(content or "").strip() @@ -45,6 +48,7 @@ class PromptSurface: content=text, priority=priority, source=source, + layer=layer if layer in LAYERS else infer_context_layer(key, source), index=self._next_index, metadata=dict(metadata or {}), ) @@ -59,6 +63,7 @@ class PromptSurface: fragment.content, priority=fragment.priority, source=fragment.source, + layer=fragment.layer, metadata=fragment.metadata, ) @@ -66,7 +71,8 @@ class PromptSurface: seen_keys: set[str] = set() seen_content: set[str] = set() rendered: list[PromptFragment] = [] - for fragment in sorted(self._fragments, key=lambda item: (item.priority, item.index)): + rank = {layer: index for index, layer in enumerate(LAYERS)} + for fragment in sorted(self._fragments, key=lambda item: (rank.get(item.layer, len(LAYERS)), item.priority, item.index)): key = fragment.normalized_key() content = str(fragment.content or "").strip() content_sig = content @@ -88,6 +94,7 @@ class PromptSurface: item = { "key": fragment.normalized_key(), "source": _single_line(fragment.source, 80), + "layer": fragment.layer, "priority": int(fragment.priority), "content": content, "chars": len(content), diff --git a/tests/fixtures/context_orchestration_v1.json b/tests/fixtures/context_orchestration_v1.json new file mode 100644 index 0000000..09e833f --- /dev/null +++ b/tests/fixtures/context_orchestration_v1.json @@ -0,0 +1 @@ +{"contract_name":"ops.context_orchestration.v1","contract_version":"1.0","attribute_name":"_ops_context_orchestration_v1","fixture_version":"1","layers":["persona","runtime","person","scene","memory","safety"],"phases":["initialized","companion_ready","memory_ready","safety_ready","finalized","invalid"],"security_statuses":["allowed","sanitized","blocked","quarantined","unavailable"],"policies":["inherit","allow","deny","quarantine"],"trust_levels":["T0","T1","T2","T3","T4"],"state_fields":["contract_name","contract_version","contract_fingerprint","request_id","session_id","scope","created_at","phase","completed_layers","fragments","security","errors","finalized"],"security_fields":["status","event_id","memory_policy","tool_policy","response_policy","reason_codes"],"fragment_fields":["key","layer","source","trust_level","content_hash","chars","status"],"limits":{"fragments":64,"errors":16,"reason_codes":16}} diff --git a/tests/test_p2_unified_person_bridge.py b/tests/test_p2_unified_person_bridge.py index a625447..3fc29a9 100644 --- a/tests/test_p2_unified_person_bridge.py +++ b/tests/test_p2_unified_person_bridge.py @@ -22,6 +22,7 @@ if _PACKAGE_NAME not in sys.modules: sys.modules[_PACKAGE_NAME] = package adapter_module = importlib.import_module(f"{_PACKAGE_NAME}.memory_companion_adapter") +p3_contract = importlib.import_module(f"{_PACKAGE_NAME}.context_orchestration") contract = importlib.import_module(f"{_PACKAGE_NAME}.unified_person_contract") platform_module = importlib.import_module(f"{_PACKAGE_NAME}.platform_compat") registry_module = importlib.import_module(f"{_PACKAGE_NAME}.unified_person_registry") @@ -137,7 +138,15 @@ class UnifiedPersonComposeBridgeTests(unittest.TestCase): host.data["unified_person"]["identity_links"][identity_key]["identity_assurance"] = assurance return person_id - def _compose(self, host: _Host, event, *, user_id: str = "") -> dict: + def _compose(self, host: _Host, event, *, user_id: str = "", person_ready: bool = True) -> dict | None: + state = p3_contract.new_context_state(session_id=event.unified_msg_origin, scope="private") + for layer in ("persona", "runtime"): + p3_contract.complete_layer(state, layer) + if person_ready: + p3_contract.complete_layer(state, "person") + p3_contract.complete_layer(state, "scene") + p3_contract.attach_context_state(state, event=event) + call_count = len(host.bridge.calls) asyncio.run( host._memory_companion_compose_feature_context( kind="p2_person_gate", @@ -146,7 +155,7 @@ class UnifiedPersonComposeBridgeTests(unittest.TestCase): user_id=user_id, ) ) - return host.bridge.calls[-1]["session_context"] + return host.bridge.calls[-1]["session_context"] if len(host.bridge.calls) > call_count else None def test_resolved_high_assurance_projection_reaches_real_compose_context(self): host = _Host() @@ -174,15 +183,15 @@ class UnifiedPersonComposeBridgeTests(unittest.TestCase): self.assertEqual(exact["unified_person_projection"]["person_id"], exact_person_id) self.assertEqual(exact["unified_person_source_identity"]["adapter_instance_id"], "onebot-a") - ambiguous = self._compose(exact_host, _event("42", adapter="onebot")) - self.assertNotIn("unified_person_projection", ambiguous) + ambiguous = self._compose(exact_host, _event("42", adapter="onebot"), person_ready=False) + self.assertIsNone(ambiguous) exact_host.context.platform_manager = _PlatformManager([ _Platform("onebot-a", "aiocqhttp"), _Platform("onebot-b", "aiocqhttp"), ]) - ambiguous_name = self._compose(exact_host, _event("42", adapter="aiocqhttp")) - self.assertNotIn("unified_person_projection", ambiguous_name) + ambiguous_name = self._compose(exact_host, _event("42", adapter="aiocqhttp"), person_ready=False) + self.assertIsNone(ambiguous_name) def test_missing_dimension_pending_and_low_assurance_fail_closed(self): missing_host = _Host() diff --git a/tests/test_p3_context_orchestration.py b/tests/test_p3_context_orchestration.py new file mode 100644 index 0000000..90dd984 --- /dev/null +++ b/tests/test_p3_context_orchestration.py @@ -0,0 +1,86 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations +import asyncio, importlib, json, pathlib, sys, types, unittest +from copy import deepcopy +from types import SimpleNamespace +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) +import _host_stub # noqa: E402 +_host_stub.install() +PACKAGE = "_p3_context_companion" +if PACKAGE not in sys.modules: + package = types.ModuleType(PACKAGE); package.__path__ = [str(pathlib.Path(__file__).resolve().parents[1])]; sys.modules[PACKAGE] = package +contract = importlib.import_module(f"{PACKAGE}.context_orchestration") +surface_module = importlib.import_module(f"{PACKAGE}.prompt_surface") +adapter = importlib.import_module(f"{PACKAGE}.memory_companion_adapter") + +class _Bridge: + def __init__(self): self.calls = [] + async def compose_context(self, **kwargs): self.calls.append(kwargs); return "memory" +class _Host(adapter.MemoryCompanionAdapterMixin): + def __init__(self): self.enable_memory_companion_feature_context=True; self.memory_companion_context_top_k=5; self.memory_companion_context_max_chars=900; self.memory_companion_context_timeout_seconds=2; self.bridge=_Bridge(); self.data={}; self.authority={} + def _memory_companion_bridge(self): return self.bridge + def _memory_companion_bridge_bot_id(self,event=None): return "bot" + def _memory_companion_bot_emotional_state(self): return "steady", .5 + def _sender_display_name(self,event): return "Alice" + def _memory_companion_unified_person_authority(self,event,expected_user_id=""): return dict(self.authority) + +class P3ContextTests(unittest.TestCase): + def test_descriptor_fingerprint_and_constants(self): + descriptor = contract.contract_descriptor() + fixture = json.loads((pathlib.Path(__file__).parent / "fixtures" / "context_orchestration_v1.json").read_text(encoding="utf-8")) + self.assertEqual(fixture, descriptor) + self.assertEqual(len(contract.contract_fingerprint()), 64) + self.assertEqual((contract.CONTEXT_INIT,contract.COMPANION_CONTEXT,contract.TTS_FALLBACK,contract.MEMORY_CONTEXT,contract.INCOMPATIBLE_TOOL,contract.SENSITIVE_TOOL,contract.FINALIZE),(100,0,-10,-20,-20000,-21000,-22000)) + def test_created_at_is_valid_projected_and_immutable(self): + fixed = "2026-07-29T00:00:00.000Z" + state = contract.new_context_state(created_at=fixed) + contract.complete_layer(state, "persona") + self.assertEqual(state["created_at"], fixed) + self.assertEqual(contract.project_context_state(state)["created_at"], fixed) + invalid = deepcopy(state); invalid["created_at"] = "" + self.assertEqual(contract.consume_context_state(invalid)["phase"], "invalid") + def test_controlled_codes_reject_untrusted_values_without_coercion(self): + accepted = contract.new_context_state() + contract.update_security(accepted, reason_codes="a" * 120) + self.assertEqual(accepted["security"]["reason_codes"], ["a" * 120]) + for value in ("", "a" * 121, "bad code", "bad\ncode", 7): + state = contract.new_context_state() + contract.update_security(state, reason_codes=[value]) + self.assertEqual(state["phase"], "invalid") + self.assertIn("reason_code_invalid", state["errors"]) + malformed = contract.new_context_state() + malformed["errors"] = ["raw prose"] + self.assertEqual(contract.consume_context_state(malformed)["phase"], "invalid") + def test_order_dedupe_and_private_context_person(self): + s=surface_module.PromptSurface() + for layer in reversed(contract.LAYERS): s.add(layer,layer,priority=-99,source="private.context" if layer=="person" else layer,layer=layer) + s.add("persona","duplicate",source="persona",layer="persona") + self.assertEqual([x["layer"] for x in s.rendered_fragments()],list(contract.LAYERS)) + self.assertEqual(contract.infer_context_layer("x","private.context"),"person") + def test_dual_carrier_finalized_immutable_and_finalize_requires_all_layers(self): + state=contract.new_context_state(); req,event=SimpleNamespace(),SimpleNamespace(); contract.attach_context_state(state,req,event); self.assertIs(contract.read_context_state(req,event),state) + for layer in contract.LAYERS[:-1]: contract.complete_layer(state,layer) + contract.finalize_state(state); self.assertFalse(state["finalized"]) + contract.complete_layer(state,"safety"); contract.finalize_state(state); before=deepcopy(state); self.assertTrue(state["finalized"]) + contract.complete_layer(state,"bad"); contract.update_security(state,status="blocked"); contract.register_fragment(state,key="x",layer="scene",content="raw"); self.assertEqual(state,before) + def test_bad_layer_metadata_only_and_bridge_does_not_complete_layers(self): + state=contract.new_context_state(); contract.complete_layer(state,"bad"); self.assertEqual(state["phase"],"invalid") + state=contract.new_context_state(); contract.register_fragment(state,key="m",layer="scene",content="raw secret"); self.assertNotIn("content",state["fragments"][0]) + host=_Host(); event=SimpleNamespace(unified_msg_origin="x:FriendMessage:42",get_sender_id=lambda:"42",get_platform_name=lambda:"x",is_private_chat=lambda:True) + self.assertEqual(asyncio.run(host._memory_companion_compose_feature_context(kind="p3",query="x",event=event,user_id="42")),"memory") + self.assertTrue(host.bridge.calls[-1]["session_context"]["strict_session_only"]) + legacy_calls=len(host.bridge.calls) + host.authority={"unified_person_projection":{"person_id":"p"},"unified_person_source_identity":{"platform_subject_id":"42"}} + self.assertEqual(asyncio.run(host._memory_companion_compose_feature_context(kind="p3",query="x",event=event,user_id="42")),"") + self.assertEqual(len(host.bridge.calls),legacy_calls) + host.authority={} + contract.attach_context_state(state,event=event) + self.assertEqual(asyncio.run(host._memory_companion_compose_feature_context(kind="p3",query="x",event=event,user_id="42")),"") + self.assertEqual(len(host.bridge.calls),legacy_calls) + for layer in ("persona","runtime","person","scene"): + contract.complete_layer(state,layer) + host.authority={"unified_person_projection":{"person_id":"p"},"unified_person_source_identity":{"platform_subject_id":"42"}} + asyncio.run(host._memory_companion_compose_feature_context(kind="p3",query="x",event=event,user_id="42")) + self.assertEqual(host.bridge.calls[-1]["session_context"]["context_orchestration"]["phase"],"companion_ready") + +if __name__ == "__main__": unittest.main() diff --git a/tests/test_p4_affinity_confinement.py b/tests/test_p4_affinity_confinement.py new file mode 100644 index 0000000..e1a2cc2 --- /dev/null +++ b/tests/test_p4_affinity_confinement.py @@ -0,0 +1,233 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +from copy import deepcopy +from datetime import datetime, timedelta, timezone + +from p4_affinity_confinement import ( + POLICY_VERSION, + REVIEW_SCHEMA_VERSION, + evaluate_violation_policy, + new_shadow_state, + replay_shadow_events, + settle_shadow_event, + validate_review_result, +) + + +UTC = timezone.utc + + +def _at(day: int, hour: int = 0) -> str: + return (datetime(2026, 1, 1, hour, tzinfo=UTC) + timedelta(days=day)).isoformat().replace("+00:00", "Z") + + +def _review(category: str = "prompt_injection", *, confidence: float = 0.99, flags: list[str] | None = None) -> dict: + return { + "schema_version": REVIEW_SCHEMA_VERSION, + "verdict": "violation", + "category": category, + "confidence": confidence, + "risk_flags": flags or [], + "evidence": [{"message_id": "m-1", "code": "direct_instruction_override"}], + } + + +def _violation(event_id: str, day: int, review: dict | None = None) -> dict: + return { + "event_id": event_id, + "occurred_at": _at(day), + "kind": "violation", + "policy_version": POLICY_VERSION, + "review": review or _review(), + } + + +def _positive(event_id: str, day: int, *, group_percent: int = 100) -> dict: + return { + "event_id": event_id, + "occurred_at": _at(day), + "kind": "positive", + "policy_version": POLICY_VERSION, + "positive_category": "reliable_help", + "base_points": 4, + "is_group": group_percent != 100, + "group_affinity_weight_percent": group_percent, + } + + +def test_review_validation_rejects_executable_or_prose_fields_and_policy_owns_steps(): + valid = _review("doxxing") + assert validate_review_result(valid)["valid"] is True + decision = evaluate_violation_policy(valid) + assert decision["steps"] == 3 + assert decision["minimum_confinement_days"] == 9 + + for forbidden in ("severity_steps", "score_delta", "confinement_days", "warning_text", "explanation"): + bad = deepcopy(valid) + bad[forbidden] = 3 if forbidden != "warning_text" else "do not do this" + assert validate_review_result(bad)["valid"] is False + assert evaluate_violation_policy(bad)["steps"] == 0 + + uncertain = deepcopy(valid) + uncertain["verdict"] = "uncertain" + assert evaluate_violation_policy(uncertain)["steps"] == 0 + + +def test_normal_chat_never_auto_warms_and_inputs_are_not_mutated(): + state = new_shadow_state() + event = {"event_id": "normal-1", "occurred_at": _at(0), "kind": "normal"} + state_before, event_before = deepcopy(state), deepcopy(event) + result = settle_shadow_event(state, event) + + assert result["outcome"] == "normal_no_settlement" + assert result["state"]["score"] == 0 + assert state == state_before + assert event == event_before + duplicate = settle_shadow_event(result["state"], event) + assert duplicate["outcome"] == "idempotent" + assert duplicate["state"] == result["state"] + + +def test_ordinary_chat_invalid_review_and_owner_events_fail_closed_without_penalty(): + state = new_shadow_state() + for event_id in ("greeting", "spam", "disagreement"): + state = settle_shadow_event(state, { + "event_id": event_id, + "occurred_at": _at(0), + "kind": "normal", + })["state"] + assert state["score"] == 0 + + low_confidence = settle_shadow_event(state, _violation( + "low-confidence", + 0, + _review(confidence=0.89), + )) + assert low_confidence["outcome"] == "violation_no_penalty" + assert low_confidence["state"]["score"] == 0 + + owner = settle_shadow_event(low_confidence["state"], { + **_violation("owner-violation", 0), + "is_owner": True, + }) + assert owner["outcome"] == "owner_automatic_exempt" + assert owner["state"]["score"] == 0 + + +def test_positive_caps_and_group_weight_are_deterministic(): + grouped = settle_shadow_event(new_shadow_state(), _positive("group-1", 0, group_percent=50)) + assert grouped["state"]["score"] == 2 + assert grouped["details"]["delta"] == 2 + + state = new_shadow_state() + for event_id in ("daily-1", "daily-2", "daily-3"): + result = settle_shadow_event(state, _positive(event_id, 0)) + state = result["state"] + assert state["score"] == 8 + assert result["outcome"] == "positive_capped" + + # The rolling seven-day cap continues after the daily cap reset. + for day in (1, 2): + for suffix in ("a", "b"): + state = settle_shadow_event(state, _positive(f"week-{day}-{suffix}", day))["state"] + state = settle_shadow_event(state, _positive("week-3-a", 3))["state"] + final = settle_shadow_event(state, _positive("week-3-b", 3)) + assert final["state"]["score"] == 30 + assert final["details"]["delta"] == 2 + + +def test_three_warnings_and_direct_high_risk_confinement_rounds(): + state = new_shadow_state() + for event_id in ("v-1", "v-2", "v-3"): + state = settle_shadow_event(state, _violation(event_id, 0))["state"] + assert state["score"] == -1200 + assert state["warning_stage"] == "confinement" + assert state["confinement_round"] == 1 + assert state["confinement_duration_days"] == 1 + + high = settle_shadow_event(new_shadow_state(), _violation("high-1", 0, _review("doxxing"))) + assert high["state"]["score"] == -1200 + assert high["state"]["confinement_round"] == 1 + assert high["state"]["confinement_duration_days"] == 9 + + +def test_expiry_release_prompt_recovery_and_violation_priority(): + state = new_shadow_state() + for event_id in ("e-v1", "e-v2", "e-v3"): + state = settle_shadow_event(state, _violation(event_id, 0))["state"] + + # Six elapsed days do not skip the one-shot release prompt. + released = settle_shadow_event(state, {"event_id": "normal-release", "occurred_at": _at(7), "kind": "normal"}) + assert released["outcome"] == "release_prompt_only" + assert released["state"]["score"] == -800 + recovered = settle_shadow_event(released["state"], {"event_id": "normal-recover", "occurred_at": _at(7, 1), "kind": "normal"}) + assert recovered["outcome"] == "recovery_settled" + assert recovered["state"]["score"] == 0 + assert recovered["state"]["confinement_round"] == 0 + + # A confirmed violation at the recovery trigger has priority over recovery. + state = new_shadow_state() + for event_id in ("p-v1", "p-v2", "p-v3"): + state = settle_shadow_event(state, _violation(event_id, 0))["state"] + priority = settle_shadow_event(state, _violation("p-v4", 7)) + assert priority["outcome"] == "violation_confinement" + assert priority["state"]["score"] == -1200 + assert priority["state"]["confinement_round"] == 2 + + +def test_owner_release_and_misjudgment_are_shadow_replay_inputs(): + healthy = settle_shadow_event(new_shadow_state(), { + "event_id": "release-healthy", "occurred_at": _at(0), "kind": "owner_release", "actor_is_owner": True, + }) + assert healthy["outcome"] == "owner_release_not_confined" + assert healthy["state"]["score"] == 0 + assert healthy["state"]["release_prompt_pending"] is False + + first = settle_shadow_event(new_shadow_state(), _violation("bad-1", 0, _review("doxxing"))) + denied = settle_shadow_event(first["state"], {"event_id": "release-denied", "occurred_at": _at(1), "kind": "owner_release"}) + assert denied["outcome"] == "owner_required" + released = settle_shadow_event(denied["state"], { + "event_id": "release-owner", "occurred_at": _at(1), "kind": "owner_release", "actor_is_owner": True, + }) + assert released["state"]["score"] == -800 + assert released["state"]["confinement_round"] == 1 + assert released["state"]["release_prompt_pending"] is True + + replayed = settle_shadow_event(first["state"], { + "event_id": "misjudge-1", "occurred_at": _at(1), "kind": "misjudgment", + "actor_is_owner": True, "revoke_event_id": "bad-1", + }) + assert replayed["outcome"] == "misjudgment_replayed" + assert replayed["state"]["score"] == 0 + assert "bad-1" in replayed["state"]["revoked_event_ids"] + + most_recent = settle_shadow_event(first["state"], { + "event_id": "misjudge-most-recent", "occurred_at": _at(1), "kind": "misjudgment", + "actor_is_owner": True, + }) + assert most_recent["outcome"] == "misjudgment_replayed" + assert most_recent["state"]["score"] == 0 + assert most_recent["state"]["event_log"][-1]["revoke_event_id"] == "bad-1" + + normal = settle_shadow_event(new_shadow_state(), {"event_id": "normal-only", "occurred_at": _at(0), "kind": "normal"}) + not_violation = settle_shadow_event(normal["state"], { + "event_id": "misjudge-normal", "occurred_at": _at(1), "kind": "misjudgment", + "actor_is_owner": True, "revoke_event_id": "normal-only", + }) + assert not_violation["outcome"] == "revoke_target_not_violation" + assert not_violation["state"]["score"] == 0 + + invalid_target = settle_shadow_event(first["state"], { + "event_id": "misjudge-invalid-target", "occurred_at": _at(1), "kind": "misjudgment", + "actor_is_owner": True, "revoke_event_id": "invalid target", + }) + assert invalid_target["outcome"] == "misjudgment_rejected" + assert invalid_target["state"]["score"] == -1200 + assert invalid_target["state"]["revoked_event_ids"] == [] + + via_replay = replay_shadow_events([ + _violation("ledger-bad", 0, _review("doxxing")), + {"event_id": "ledger-fix", "occurred_at": _at(1), "kind": "misjudgment", "actor_is_owner": True, "revoke_event_id": "ledger-bad"}, + ]) + assert via_replay["state"]["score"] == 0 diff --git a/tests/test_p4_capabilities.py b/tests/test_p4_capabilities.py new file mode 100644 index 0000000..e6bdc4b --- /dev/null +++ b/tests/test_p4_capabilities.py @@ -0,0 +1,113 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +import dataclasses +from pathlib import Path +import sys +import unittest + +ROOT = Path(__file__).resolve().parents[1] +if str(ROOT) not in sys.path: + sys.path.insert(0, str(ROOT)) + +from p4_capabilities import ( + P4_CAPABILITY_BY_ID, + P4_CAPABILITY_REGISTRY, + SAFE_EVENT_ID_RE, + is_exact_p4_management_command, + parse_p4_management_command, +) + + +PERSON_ID = "person_0123456789abcdef01234567" +IDENTITY_KEY = "ops-origin-v1:" + ("a" * 64) +EVENT_ID = "ledger:2026/07+owner@a.b-1" + + +class P4CapabilityTests(unittest.TestCase): + def test_exact_registered_forms_accept_only_stable_targets(self) -> None: + cases = [ + (f"/放出 {PERSON_ID}", "p4.owner_release", PERSON_ID, "person_id", None), + (f"/放出 {IDENTITY_KEY}", "p4.owner_release", IDENTITY_KEY, "p0_identity_key", None), + (f"/误判 {PERSON_ID}", "p4.owner_misjudgment", PERSON_ID, "person_id", None), + (f"/误判 {IDENTITY_KEY} {EVENT_ID}", "p4.owner_misjudgment", IDENTITY_KEY, "p0_identity_key", EVENT_ID), + ] + for payload, capability_id, target, target_kind, event_id in cases: + with self.subTest(payload=payload): + parsed = parse_p4_management_command(payload) + self.assertIsNotNone(parsed) + assert parsed is not None + self.assertEqual(parsed.capability_id, capability_id) + self.assertEqual(parsed.target, target) + self.assertEqual(parsed.target_kind, target_kind) + self.assertEqual(parsed.event_id, event_id) + self.assertTrue(is_exact_p4_management_command(payload)) + + def test_registry_metadata_is_immutable_and_explicitly_not_self_service(self) -> None: + self.assertEqual( + tuple(capability.capability_id for capability in P4_CAPABILITY_REGISTRY), + ("p4.owner_release", "p4.owner_misjudgment"), + ) + self.assertEqual(set(P4_CAPABILITY_BY_ID), {"p4.owner_release", "p4.owner_misjudgment"}) + + for capability in P4_CAPABILITY_REGISTRY: + with self.subTest(capability_id=capability.capability_id): + self.assertEqual(capability.group, "p4_affinity_confinement") + self.assertTrue(capability.tool.startswith("owner_")) + self.assertTrue(capability.sensitivity.startswith("owner_only_")) + self.assertTrue(capability.requires_owner_authorization) + self.assertFalse(capability.self_service_allowed) + self.assertEqual(capability.execution_mode, "shadow_advisory_only") + with self.assertRaises(dataclasses.FrozenInstanceError): + capability.tool = "unsafe" # type: ignore[misc] + + with self.assertRaises(TypeError): + P4_CAPABILITY_BY_ID["p4.appeal"] = P4_CAPABILITY_REGISTRY[0] # type: ignore[index] + self.assertIsNone(parse_p4_management_command(f"/申诉 {PERSON_ID}")) + self.assertIsNone(parse_p4_management_command(f"/appeal {PERSON_ID}")) + + def test_malformed_mixed_or_nonpure_payload_never_matches(self) -> None: + cases: list[object] = [ + None, + 1, + "", + "/放出", + "/误判", + f"/放出 {PERSON_ID} ", + f" /放出 {PERSON_ID}", + f"/放出 {PERSON_ID}", + f"/放出\t{PERSON_ID}", + f"/放出 {PERSON_ID}\n", + f"请放出 /放出 {PERSON_ID}", + f"/放出 {PERSON_ID} 谢谢", + f"/误判 {PERSON_ID} {EVENT_ID} 请立即执行", + f"/误判 {PERSON_ID} {EVENT_ID} extra", + f"/误判 {PERSON_ID}\n{EVENT_ID}", + f"/误判 {PERSON_ID} {EVENT_ID}", + f"/未知 {PERSON_ID}", + "/放出 alice", + "/放出 12345678", + "/放出 person_0123456789abcdef0123456g", + "/放出 person_0123456789abcdef012345678", + "/放出 ops-origin-v1:" + ("A" * 64), + f"/误判 {PERSON_ID} _bad-event", + f"/误判 {PERSON_ID} bad event", + f"/误判 {PERSON_ID} " + ("a" * 129), + f"/放出 {PERSON_ID}; /误判 {PERSON_ID}", + ] + for payload in cases: + with self.subTest(payload=payload): + self.assertIsNone(parse_p4_management_command(payload)) + self.assertFalse(is_exact_p4_management_command(payload)) + + def test_event_id_grammar_matches_the_p4_engine_safe_identifier_contract(self) -> None: + self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch(EVENT_ID)) + self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch("A")) + self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch("a" * 128)) + self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("a" * 129)) + self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("_starts_wrong")) + self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("has whitespace")) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_p4_joint_workspace.py b/tests/test_p4_joint_workspace.py new file mode 100644 index 0000000..3691924 --- /dev/null +++ b/tests/test_p4_joint_workspace.py @@ -0,0 +1,155 @@ +# -*- coding: utf-8 -*- +"""P4-A cross-repository acceptance harness for the checked-out workspace. + +This test intentionally verifies the producer/consumer boundary rather than +teaching the memory plugin P4 business rules. It requires the documented +sibling repository layout and is a local-workspace acceptance test. +""" +from __future__ import annotations + +from copy import deepcopy +from dataclasses import fields +from pathlib import Path +import sys +import unittest + +from context_orchestration import ( + FINALIZE, + contract_descriptor as companion_p3_descriptor, + contract_fingerprint as companion_p3_fingerprint, +) +from unified_person_contract import ( + CONTRACT_FINGERPRINT as COMPANION_P0_FINGERPRINT, + build_person_projection, + empty_unified_person_store, +) +from unified_person_registry import UnifiedPersonRegistry + + +WORKSPACE_ROOT = Path(__file__).resolve().parents[2] +MEMORY_ROOT = WORKSPACE_ROOT / "astrbot_plugin_memory_companion-main" +if str(MEMORY_ROOT) not in sys.path: + sys.path.insert(0, str(MEMORY_ROOT)) + +from core import context_orchestration as memory_p3 # noqa: E402 +from core.bridge import MemoryCompanionBridge # noqa: E402 +from core.models import MemoryRecord, SessionContext # noqa: E402 +from core.service import MemoryCompanionService # noqa: E402 +from core.unified_person_contract import contract_fingerprint as memory_p0_fingerprint # noqa: E402 + + +P0_FINGERPRINT = "633e2d235345d5c1bb72f8e6247e61932c5215ad2817242eefb709b502aefe03" +P3_FINGERPRINT = "3bb7a12af05bb4d9a47cef9f31e78752cec512b90b1d50ae49feef54470974f8" +P4_STATE_FIELDS = { + "affinity_score", + "affinity_band", + "warning_stage", + "confinement_state", + "confinement_until", + "confinement_round", + "release_prompt_pending", +} + + +@unittest.skipUnless(MEMORY_ROOT.is_dir(), "P4 joint workspace requires the memory companion sibling repository") +class P4JointWorkspaceTests(unittest.TestCase): + def test_p4_shadow_ledger_stays_companion_only_and_p0_p3_contracts_do_not_drift(self): + self.assertEqual(COMPANION_P0_FINGERPRINT, P0_FINGERPRINT) + self.assertEqual(memory_p0_fingerprint(), P0_FINGERPRINT) + self.assertEqual(companion_p3_descriptor(), memory_p3.contract_descriptor()) + self.assertEqual(companion_p3_fingerprint(), P3_FINGERPRINT) + self.assertEqual(memory_p3.contract_fingerprint(), P3_FINGERPRINT) + self.assertEqual(FINALIZE, -22000) + + observed_identity = { + "companion_instance_id": "companion-a", + "bot_account_id": "bot-a", + "adapter_instance_id": "telegram-main", + "subject_namespace": "telegram.user", + "platform_subject_id": "42", + } + explicitly_linked_identity = { + **observed_identity, + "bot_account_id": "bot-b", + } + store = {"unified_person": empty_unified_person_store()} + registry = UnifiedPersonRegistry(store) + created = registry.upsert_observed_identity( + observed_identity, + operation_id="p4-joint-observe", + display_name="joint-user", + ) + self.assertTrue(created["ok"]) + person_id = created["person_id"] + self.assertTrue(registry.link_identity( + explicitly_linked_identity, + person_id, + operation_id="p4-joint-link", + actor_id="joint_test", + reason="p4_joint_exact_identity", + authorized=True, + )["ok"]) + self.assertTrue(registry.unlink_identity( + observed_identity, + operation_id="p4-joint-unlink", + actor_id="joint_test", + reason="p4_joint_exact_identity", + authorized=True, + )["ok"]) + projection_before = build_person_projection(store, person_id) + self.assertIsNotNone(projection_before) + assert projection_before is not None + self.assertEqual(projection_before["identity_assurance"], "explicit_linked") + profile_before = deepcopy(store["unified_person"]["profiles"][person_id]) + + shadow = registry.record_p4_shadow_event( + person_id, + { + "event_id": "p4-joint-normal-1", + "occurred_at": "2026-07-29T00:00:00Z", + "kind": "normal", + }, + operation_id="p4-joint-record-1", + actor_id="p4_joint_harness", + ) + self.assertTrue(shadow["ok"]) + self.assertEqual(shadow["p4_shadow_summary"]["score"], 0) + self.assertEqual(store["unified_person"]["profiles"][person_id], profile_before) + self.assertEqual(build_person_projection(store, person_id), projection_before) + self.assertNotIn("p4_shadow", projection_before) + self.assertEqual(len(store["unified_person"]["p4_shadow"]["people"][person_id]["events"]), 1) + + service = MemoryCompanionService.__new__(MemoryCompanionService) + bridge = MemoryCompanionBridge(service) + context = bridge._trusted_session_context( + { + "session_id": "private:42", + "scope": "private", + "unified_person_projection": projection_before, + "unified_person_source_identity": explicitly_linked_identity, + } + ) + self.assertIsInstance(context, SessionContext) + self.assertEqual(context.person_id, person_id) + self.assertEqual(context.person_origin_identity_key, projection_before["resolved_identity_key"]) + self.assertEqual(context.person_identity_assurance, "explicit_linked") + self.assertTrue(P4_STATE_FIELDS.isdisjoint(item.name for item in fields(SessionContext))) + self.assertTrue(P4_STATE_FIELDS.isdisjoint(item.name for item in fields(MemoryRecord))) + + forged_projection = deepcopy(projection_before) + forged_projection["affinity_score"] = -1201 + rejected = service.session_context_from_bridge( + { + "session_id": "private:42", + "scope": "private", + "unified_person_projection": forged_projection, + "unified_person_source_identity": explicitly_linked_identity, + } + ) + self.assertEqual(rejected.person_id, "") + self.assertEqual(rejected.person_origin_identity_key, "") + self.assertEqual(rejected.person_identity_assurance, "") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_p4_shadow_hook.py b/tests/test_p4_shadow_hook.py new file mode 100644 index 0000000..4d8a445 --- /dev/null +++ b/tests/test_p4_shadow_hook.py @@ -0,0 +1,243 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +import asyncio +from copy import deepcopy +import hashlib +import importlib +import pathlib +import sys +from types import SimpleNamespace +import types +import unittest + + +sys.path.insert(0, str(pathlib.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_shadow_hook_companion" +if PACKAGE not in sys.modules: + package = types.ModuleType(PACKAGE) + package.__path__ = [str(pathlib.Path(__file__).resolve().parents[1])] + sys.modules[PACKAGE] = package + +contract = importlib.import_module(f"{PACKAGE}.context_orchestration") +main = importlib.import_module(f"{PACKAGE}.main") +core_store = importlib.import_module(f"{PACKAGE}.core_store") +person_contract = importlib.import_module(f"{PACKAGE}.unified_person_contract") + + +PERSON_ID = "person_0123456789abcdef01234567" + + +def finalized_state(*, status: str = "allowed", response_policy: str = "inherit") -> dict: + state = contract.new_context_state(created_at="2026-07-29T00:00:00.000Z") + contract.update_security(state, status=status, response_policy=response_policy) + for layer in contract.LAYERS: + contract.complete_layer(state, layer) + contract.finalize_state(state) + assert state["finalized"] is True + return state + + +class _Host: + def __init__(self, *, enabled: bool = True, authority: dict | None = None) -> None: + self.enable_p4_shadow_observer = enabled + self.authority = authority if authority is not None else { + "unified_person_projection": { + "person_id": PERSON_ID, + "profile_status": "active", + "identity_assurance": "verified", + }, + "unified_person_source_identity": { + "companion_instance_id": "companion-a", + "bot_account_id": "bot-a", + "adapter_instance_id": "telegram-main", + "subject_namespace": "telegram.user", + "platform_subject_id": "sender-42", + }, + } + self.calls: list[tuple[tuple, dict]] = [] + + @staticmethod + def _event_message_id(event): + return str(getattr(event, "message_id", "") or "") + + @staticmethod + def _safe_event_sender_id(event): + return str(getattr(event, "sender_id", "") or "") + + def _memory_companion_unified_person_authority(self, event, *, expected_user_id=""): + if expected_user_id != "sender-42": + return {} + return deepcopy(self.authority) + + def _apply_unified_person_lifecycle(self, *args, **kwargs): + self.calls.append((args, kwargs)) + return {"ok": True, "code": "p4_shadow_event_recorded"} + + +class _RegistryHost(core_store.CoreStoreMixin, _Host): + def __init__(self) -> None: + _Host.__init__(self) + self.data = {"unified_person": person_contract.empty_unified_person_store()} + self.save_calls = 0 + + def _schedule_data_save(self) -> None: + self.save_calls += 1 + + +class P4ShadowHookTests(unittest.TestCase): + def _invoke(self, host: _Host, state: dict, *, message_id: str = "msg-42", text: str = "hello"): + event = SimpleNamespace(message_id=message_id, message_str=text, sender_id="sender-42") + request = SimpleNamespace(system_prompt="unchanged") + contract.attach_context_state(state, request, event) + state_before = deepcopy(state) + asyncio.run(main.PrivateCompanionPlugin.record_p4_shadow_normal_observer(host, event, request)) + self.assertEqual(request.system_prompt, "unchanged") + self.assertEqual(event.message_str, text) + self.assertEqual(state, state_before) + return event, request + + def test_observer_runs_after_p3_finalizer_and_writes_minimal_normal_shadow_event(self): + self.assertEqual(main.P4_SHADOW_OBSERVER_PRIORITY, contract.FINALIZE - 1000) + self.assertEqual(main.P4_SHADOW_OBSERVER_PRIORITY, -23000) + + host = _Host() + self._invoke(host, finalized_state()) + + self.assertEqual(len(host.calls), 1) + args, kwargs = host.calls[0] + self.assertEqual(args[:2], ("record_p4_shadow_event", PERSON_ID)) + event = args[2] + digest = hashlib.sha256(b"msg-42").hexdigest() + self.assertEqual(event, { + "event_id": f"p4.normal:{digest}", + "occurred_at": "2026-07-29T00:00:00.000Z", + "kind": "normal", + "firewall_safe": True, + "is_command": False, + "is_empty": False, + }) + self.assertNotIn("msg-42", repr(event)) + self.assertNotIn("hello", repr(event)) + self.assertEqual(kwargs, { + "operation_id": f"p4.shadow.normal:{PERSON_ID}:{digest}", + "actor_id": "p4_shadow_observer", + }) + + def test_observer_is_fail_closed_for_flag_p3_message_and_person_authority_gates(self): + low_assurance = _Host().authority + low_assurance["unified_person_projection"]["identity_assurance"] = "observed" + cases = [ + (_Host(enabled=False), finalized_state(), "msg-42", "hello"), + (_Host(), finalized_state(status="blocked"), "msg-42", "hello"), + (_Host(), finalized_state(status="quarantined"), "msg-42", "hello"), + (_Host(), finalized_state(status="unavailable"), "msg-42", "hello"), + (_Host(), finalized_state(response_policy="deny"), "msg-42", "hello"), + (_Host(), finalized_state(), "", "hello"), + (_Host(authority={}), finalized_state(), "msg-42", "hello"), + (_Host(authority=low_assurance), finalized_state(), "msg-42", "hello"), + ] + for host, state, message_id, text in cases: + with self.subTest(message_id=message_id, state=state["security"]["status"]): + self._invoke(host, state, message_id=message_id, text=text) + self.assertEqual(host.calls, []) + + not_finalized = contract.new_context_state(created_at="2026-07-29T00:00:00.000Z") + host = _Host() + self._invoke(host, not_finalized) + self.assertEqual(host.calls, []) + + def test_sanitized_event_is_shadowed_but_commands_and_empty_text_are_not_recovery_eligible(self): + host = _Host() + self._invoke(host, finalized_state(status="sanitized"), text="/放出 person_0123456789abcdef01234567") + self.assertEqual(host.calls[0][0][2]["is_command"], True) + + host = _Host() + self._invoke(host, finalized_state(), text=" ") + self.assertTrue(host.calls[0][0][2]["is_empty"]) + + def test_observer_errors_are_nonfatal_and_do_not_write_shadow_state(self): + class _BrokenMessageIdHost(_Host): + @staticmethod + def _event_message_id(event): + raise RuntimeError("message id unavailable") + + class _BrokenAuthorityHost(_Host): + def _memory_companion_unified_person_authority(self, event, *, expected_user_id=""): + raise RuntimeError("authority unavailable") + + for host in (_BrokenMessageIdHost(), _BrokenAuthorityHost()): + with self.subTest(host=type(host).__name__): + self._invoke(host, finalized_state()) + self.assertEqual(host.calls, []) + + def test_hook_to_registry_persists_only_p4_shadow_and_is_idempotent(self): + host = _RegistryHost() + observed_identity = { + "companion_instance_id": "companion-a", + "bot_account_id": "bot-a", + "adapter_instance_id": "telegram-main", + "subject_namespace": "telegram.user", + "platform_subject_id": "sender-42", + } + linked_identity = { + **observed_identity, + "bot_account_id": "bot-b", + } + registry = host._unified_person_registry() + created = registry.upsert_observed_identity( + observed_identity, + operation_id="p4-hook-observe", + display_name="sender", + ) + person_id = created["person_id"] + self.assertTrue(registry.link_identity( + linked_identity, + person_id, + operation_id="p4-hook-link", + actor_id="test", + reason="test_relink", + authorized=True, + )["ok"]) + self.assertTrue(registry.unlink_identity( + observed_identity, + operation_id="p4-hook-unlink", + actor_id="test", + reason="test_relink", + authorized=True, + )["ok"]) + projection_before = person_contract.build_person_projection(host.data, person_id) + self.assertIsNotNone(projection_before) + assert projection_before is not None + self.assertEqual(projection_before["identity_assurance"], "explicit_linked") + profile_before = deepcopy(host.data["unified_person"]["profiles"][person_id]) + host.authority = { + "unified_person_projection": projection_before, + "unified_person_source_identity": linked_identity, + } + + self._invoke(host, finalized_state()) + self.assertEqual(host.save_calls, 1) + self.assertEqual(host.data["unified_person"]["profiles"][person_id], profile_before) + self.assertEqual(person_contract.build_person_projection(host.data, person_id), projection_before) + entry = host.data["unified_person"]["p4_shadow"]["people"][person_id] + self.assertEqual(len(entry["events"]), 1) + self.assertEqual(entry["state"]["score"], 0) + + self._invoke(host, finalized_state()) + self.assertEqual(host.save_calls, 1) + self.assertEqual(len(entry["events"]), 1) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_p4_shadow_registry.py b/tests/test_p4_shadow_registry.py new file mode 100644 index 0000000..abf7346 --- /dev/null +++ b/tests/test_p4_shadow_registry.py @@ -0,0 +1,249 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations + +from copy import deepcopy +import importlib +import pathlib +import sys +import types +import unittest + +from unified_person_contract import build_person_projection, empty_unified_person_store +from unified_person_registry import UnifiedPersonRegistry + + +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) +import _host_stub # noqa: E402 + +_host_stub.install() + +_PACKAGE_NAME = "_p4_shadow_registry_companion" +if _PACKAGE_NAME not in sys.modules: + package = types.ModuleType(_PACKAGE_NAME) + package.__path__ = [str(pathlib.Path(__file__).resolve().parents[1])] + sys.modules[_PACKAGE_NAME] = package + +core_store_module = importlib.import_module(f"{_PACKAGE_NAME}.core_store") + + +def identity(subject_id: str) -> dict[str, str]: + return { + "companion_instance_id": "companion-a", + "bot_account_id": "bot-1", + "adapter_instance_id": "telegram-main", + "subject_namespace": "telegram.user", + "platform_subject_id": subject_id, + } + + +def normal_event(event_id: str, *, occurred_at: str = "2026-07-29T00:00:00Z") -> dict[str, str]: + return { + "event_id": event_id, + "occurred_at": occurred_at, + "kind": "normal", + } + + +def violation_event(event_id: str) -> dict: + return { + "event_id": event_id, + "occurred_at": "2026-07-29T00:00:00Z", + "kind": "violation", + "review": { + "schema_version": "p4.review.v1", + "verdict": "violation", + "category": "prompt_injection", + "confidence": 0.95, + "risk_flags": [], + "evidence": [{ + "message_id": "message-p4-1", + "code": "direct_instruction_override", + "source": "current_message", + }], + }, + } + + +class _CoreStoreHost(core_store_module.CoreStoreMixin): + def __init__(self, data: dict) -> None: + self.data = data + self.save_calls = 0 + + def _schedule_data_save(self) -> None: + self.save_calls += 1 + + +class P4ShadowRegistryTests(unittest.TestCase): + def setUp(self) -> None: + self.store = {"unified_person": empty_unified_person_store()} + self.registry = UnifiedPersonRegistry(self.store) + + def _observe(self, subject_id: str = "42") -> str: + result = self.registry.upsert_observed_identity( + identity(subject_id), + operation_id=f"observe-{subject_id}", + display_name=f"user-{subject_id}", + ) + self.assertTrue(result["ok"]) + return result["person_id"] + + def test_shadow_event_is_persisted_under_additive_container_only(self): + person_id = self._observe() + before_profile = deepcopy(self.store["unified_person"]["profiles"][person_id]) + before_projection = build_person_projection(self.store, person_id) + + result = self.registry.record_p4_shadow_event( + person_id, + normal_event("p4-event-1"), + operation_id="p4-operation-1", + actor_id="system", + ) + + self.assertTrue(result["ok"]) + self.assertTrue(result["changed"]) + self.assertEqual(result["code"], "p4_shadow_event_recorded") + self.assertEqual(result["event_id"], "p4-event-1") + self.assertEqual(self.store["unified_person"]["profiles"][person_id], before_profile) + self.assertEqual(build_person_projection(self.store, person_id), before_projection) + shadow = self.store["unified_person"]["p4_shadow"] + entry = shadow["people"][person_id] + self.assertEqual(entry["person_id"], person_id) + self.assertEqual(entry["origin_person_id"], person_id) + self.assertEqual(entry["events"][0]["person_id"], person_id) + self.assertEqual(entry["events"][0]["origin_person_id"], person_id) + self.assertEqual(entry["events"][0]["event"]["event_id"], "p4-event-1") + self.assertEqual(entry["state"]["score"], 0) + self.assertEqual(entry["state"]["event_log"][0]["event_id"], "p4-event-1") + + read = self.registry.read_p4_shadow_state(person_id) + self.assertTrue(read["ok"]) + self.assertTrue(read["p4_shadow_exists"]) + self.assertEqual(read["p4_shadow_state"], entry["state"]) + audit = self.registry.audit_events() + self.assertEqual(audit[-1]["action"], "p4_shadow_event_recorded") + self.assertEqual(audit[-1]["details"]["origin_person_id"], person_id) + + def test_registry_uses_pure_engine_for_violation_shadow_without_profile_projection_write(self): + person_id = self._observe() + before_profile = deepcopy(self.store["unified_person"]["profiles"][person_id]) + before_projection = build_person_projection(self.store, person_id) + + result = self.registry.record_p4_shadow_event( + person_id, + violation_event("p4-event-violation"), + operation_id="p4-operation-violation", + actor_id="reviewer", + ) + + self.assertTrue(result["ok"]) + self.assertTrue(result["event_applied"]) + self.assertEqual(result["p4_shadow_summary"]["score"], -400) + entry = self.store["unified_person"]["p4_shadow"]["people"][person_id] + self.assertEqual(entry["state"]["score"], -400) + self.assertEqual(entry["events"][0]["event"]["review"]["category"], "prompt_injection") + self.assertNotIn("severity_steps", entry["events"][0]["event"]["review"]) + self.assertEqual(self.store["unified_person"]["profiles"][person_id], before_profile) + self.assertEqual(build_person_projection(self.store, person_id), before_projection) + + def test_event_and_operation_idempotence_conflicts_do_not_replay_or_overwrite(self): + person_id = self._observe() + event = normal_event("p4-event-idempotent") + first = self.registry.record_p4_shadow_event( + person_id, event, operation_id="p4-operation-idempotent", actor_id="system", + ) + self.assertTrue(first["ok"]) + after_first = deepcopy(self.store) + + repeated = self.registry.record_p4_shadow_event( + person_id, event, operation_id="p4-operation-idempotent", actor_id="system", + ) + self.assertTrue(repeated["ok"]) + self.assertTrue(repeated["idempotent"]) + self.assertEqual(self.store, after_first) + + duplicate = self.registry.record_p4_shadow_event( + person_id, event, operation_id="p4-operation-new", actor_id="system", + ) + self.assertTrue(duplicate["ok"]) + self.assertEqual(duplicate["code"], "p4_shadow_event_duplicate") + self.assertFalse(duplicate["changed"]) + self.assertTrue(duplicate["event_duplicate"]) + entry = self.store["unified_person"]["p4_shadow"]["people"][person_id] + self.assertEqual(len(entry["events"]), 1) + self.assertEqual(len(self.registry.audit_events()), 2) # observed identity plus initial P4 event + after_duplicate = deepcopy(self.store) + + event_conflict = self.registry.record_p4_shadow_event( + person_id, + normal_event("p4-event-idempotent", occurred_at="2026-07-30T00:00:00Z"), + operation_id="p4-operation-event-conflict", + actor_id="system", + ) + self.assertEqual(event_conflict["code"], "p4_shadow_event_id_conflict") + self.assertEqual(self.store, after_duplicate) + + operation_conflict = self.registry.record_p4_shadow_event( + person_id, + normal_event("p4-event-other"), + operation_id="p4-operation-idempotent", + actor_id="system", + ) + self.assertEqual(operation_conflict["code"], "operation_id_conflict") + self.assertEqual(self.store, after_duplicate) + + def test_unknown_inactive_and_mismatched_origin_are_rejected_without_shadow_writes(self): + before_unknown = deepcopy(self.store) + unknown = self.registry.record_p4_shadow_event( + "person_missing", normal_event("p4-event-unknown"), operation_id="p4-operation-unknown", actor_id="system", + ) + self.assertEqual(unknown["code"], "person_not_found") + self.assertEqual(self.store, before_unknown) + + person_id = self._observe() + before_mismatch = deepcopy(self.store) + mismatch = self.registry.record_p4_shadow_event( + person_id, + {**normal_event("p4-event-mismatch"), "origin_person_id": "person_other"}, + operation_id="p4-operation-mismatch", + actor_id="system", + ) + self.assertEqual(mismatch["code"], "p4_shadow_person_mismatch") + self.assertEqual(self.store, before_mismatch) + + self.store["unified_person"]["profiles"][person_id]["profile_status"] = "suspended" + before_inactive = deepcopy(self.store) + inactive = self.registry.record_p4_shadow_event( + person_id, normal_event("p4-event-inactive"), operation_id="p4-operation-inactive", actor_id="system", + ) + self.assertEqual(inactive["code"], "person_not_active") + self.assertEqual(self.store, before_inactive) + read_inactive = self.registry.read_p4_shadow_state(person_id) + self.assertEqual(read_inactive["code"], "person_not_active") + + def test_core_store_whitelist_persists_only_non_idempotent_successes(self): + person_id = self._observe() + host = _CoreStoreHost(self.store) + event = normal_event("p4-event-core-store") + + first = host._apply_unified_person_lifecycle( + "record_p4_shadow_event", person_id, event, operation_id="p4-operation-core-store", actor_id="system", + ) + self.assertTrue(first["ok"]) + self.assertEqual(host.save_calls, 1) + repeated = host._apply_unified_person_lifecycle( + "record_p4_shadow_event", person_id, event, operation_id="p4-operation-core-store", actor_id="system", + ) + self.assertTrue(repeated["idempotent"]) + self.assertEqual(host.save_calls, 1) + duplicate = host._apply_unified_person_lifecycle( + "record_p4_shadow_event", person_id, event, operation_id="p4-operation-core-store-duplicate", actor_id="system", + ) + self.assertEqual(duplicate["code"], "p4_shadow_event_duplicate") + self.assertEqual(host.save_calls, 2) + unsupported = host._apply_unified_person_lifecycle("read_p4_shadow_state", person_id) + self.assertEqual(unsupported["code"], "unsupported_lifecycle_operation") + self.assertEqual(host.save_calls, 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/unified_person_registry.py b/unified_person_registry.py index b085937..6bcc5a7 100644 --- a/unified_person_registry.py +++ b/unified_person_registry.py @@ -21,6 +21,11 @@ try: ensure_unified_person_store, person_id_for_identity, ) + from .p4_affinity_confinement import ( + new_shadow_state, + replay_shadow_events, + settle_shadow_event, + ) except ImportError: from unified_person_contract import ( build_identity_key, @@ -28,11 +33,17 @@ except ImportError: ensure_unified_person_store, person_id_for_identity, ) + from p4_affinity_confinement import ( + new_shadow_state, + replay_shadow_events, + settle_shadow_event, + ) REGISTRY_VERSION = 1 _REGISTRY_LOCK = threading.RLock() _MAX_AUDIT_EVENTS = 1000 +_P4_SHADOW_VERSION = 1 def _now() -> str: @@ -147,6 +158,104 @@ def _ensure_registry(root: dict[str, Any]) -> None: root.setdefault("merge_operations", {}) +def _p4_shadow_container(root: dict[str, Any]) -> dict[str, Any]: + """Return the additive, companion-only P4-A persistence container.""" + container = root.get("p4_shadow") + if not isinstance(container, dict): + container = {} + root["p4_shadow"] = container + if not isinstance(container.get("version"), int): + container["version"] = _P4_SHADOW_VERSION + people = container.get("people") + if not isinstance(people, dict): + container["people"] = {} + return container + + +def _p4_shadow_event_fingerprint(person_id: str, event: dict[str, Any]) -> str: + return hashlib.sha256(_canonical({"person_id": person_id, "event": event}).encode("utf-8")).hexdigest() + + +def _normalize_p4_shadow_event(event: Any) -> tuple[dict[str, Any] | None, list[str]]: + """Let the pure engine sanitize one event before it reaches persistence.""" + result = settle_shadow_event(new_shadow_state(), deepcopy(event)) + state = result.get("state") if isinstance(result, dict) else None + event_id = str(result.get("event_id") or "") if isinstance(result, dict) else "" + log = state.get("event_log") if isinstance(state, dict) else None + if not event_id or not isinstance(log, list): + details = result.get("details") if isinstance(result, dict) and isinstance(result.get("details"), dict) else {} + codes = details.get("codes") if isinstance(details.get("codes"), list) else ["invalid_p4_shadow_event"] + return None, [str(item) for item in codes] + for item in log: + if isinstance(item, dict) and item.get("event_id") == event_id: + return deepcopy(item), [] + return None, ["invalid_p4_shadow_event"] + + +def _new_p4_shadow_person_entry(person_id: str, now: str) -> dict[str, Any]: + state = new_shadow_state() + return { + "person_id": person_id, + "origin_person_id": person_id, + "state": state, + # This is an append-only, engine-sanitized ledger. It must remain + # replayable for a future owner misjudgment event, so the registry never + # truncates it independently of the deterministic engine. + "events": [], + "created_at": now, + "updated_at": now, + "last_operation_id": "", + } + + +def _replay_p4_shadow_entry(entry: Any, person_id: str) -> tuple[dict[str, Any] | None, dict[str, dict[str, Any]] | None, str]: + """Fail closed if a persisted P4 entry loses its identity or replay proof.""" + if not isinstance(entry, dict): + return None, None, "p4_shadow_corrupt" + if entry.get("person_id") != person_id or entry.get("origin_person_id") != person_id: + return None, None, "p4_shadow_person_conflict" + envelopes = entry.get("events") + if not isinstance(envelopes, list): + return None, None, "p4_shadow_corrupt" + events: list[dict[str, Any]] = [] + event_index: dict[str, dict[str, Any]] = {} + for envelope in envelopes: + if not isinstance(envelope, dict): + return None, None, "p4_shadow_corrupt" + if envelope.get("person_id") != person_id or envelope.get("origin_person_id") != person_id: + return None, None, "p4_shadow_person_conflict" + event = envelope.get("event") + event_id = envelope.get("event_id") + if not isinstance(event, dict) or not isinstance(event_id, str) or event.get("event_id") != event_id or event_id in event_index: + return None, None, "p4_shadow_corrupt" + fingerprint = envelope.get("event_fingerprint") + if not isinstance(fingerprint, str) or fingerprint != _p4_shadow_event_fingerprint(person_id, event): + return None, None, "p4_shadow_corrupt" + event_index[event_id] = envelope + events.append(event) + replay = replay_shadow_events(events) + state = replay.get("state") if isinstance(replay, dict) else None + if not isinstance(state, dict): + return None, None, "p4_shadow_corrupt" + # The persisted state is only a cached replay result. A mismatch must not + # silently change a later safety decision. + if entry.get("state") != state: + return None, None, "p4_shadow_state_mismatch" + return deepcopy(state), event_index, "" + + +def _p4_shadow_summary(state: dict[str, Any]) -> dict[str, Any]: + return { + "mode": str(state.get("mode") or "shadow"), + "policy_version": str(state.get("policy_version") or ""), + "score": int(state.get("score") or 0), + "warning_stage": str(state.get("warning_stage") or "none"), + "confinement_state": str(state.get("confinement_state") or "none"), + "confinement_round": int(state.get("confinement_round") or 0), + "release_prompt_pending": bool(state.get("release_prompt_pending")), + } + + class UnifiedPersonRegistry: """Companion-only lifecycle authority. No consumer receives a write method.""" @@ -182,6 +291,209 @@ class UnifiedPersonRegistry: events = root.get("audit_events") if isinstance(root.get("audit_events"), list) else [] return deepcopy(events[-max(1, min(int(limit), _MAX_AUDIT_EVENTS)):]) + def read_p4_shadow_state(self, person_id: str) -> dict[str, Any]: + """Read one active person's non-projecting P4-A shadow state.""" + try: + person_id = _identifier(person_id, "person_id") + except ValueError: + return _result(False, "invalid_request") + with _REGISTRY_LOCK: + root = self._root_copy() + profile = root["profiles"].get(person_id) + if not isinstance(profile, dict): + return _result(False, "person_not_found", person_id=person_id) + if profile.get("person_id") != person_id: + return _result(False, "person_profile_conflict", person_id=person_id) + if profile.get("profile_status") != "active": + return _result(False, "person_not_active", person_id=person_id) + container = root.get("p4_shadow") + people = container.get("people") if isinstance(container, dict) and isinstance(container.get("people"), dict) else {} + entry = people.get(person_id) + if entry is None: + state = new_shadow_state() + return _result( + True, + "p4_shadow_state", + person_id=person_id, + origin_person_id=person_id, + p4_shadow_exists=False, + p4_shadow_state=state, + p4_shadow_summary=_p4_shadow_summary(state), + event_count=0, + ) + state, event_index, error = _replay_p4_shadow_entry(entry, person_id) + if error: + return _result(False, error, person_id=person_id) + assert state is not None and event_index is not None + return _result( + True, + "p4_shadow_state", + person_id=person_id, + origin_person_id=person_id, + p4_shadow_exists=True, + p4_shadow_state=state, + p4_shadow_summary=_p4_shadow_summary(state), + event_count=len(event_index), + ) + + def record_p4_shadow_event( + self, + person_id: str, + event: dict[str, Any], + *, + operation_id: str, + actor_id: str = "system", + ) -> dict[str, Any]: + """Persist one engine-sanitized P4-A event without changing a profile. + + The profile and P0/P2 projection deliberately remain untouched. The + resulting state is a replayable shadow ledger under ``p4_shadow`` only. + """ + try: + operation_id = _identifier(operation_id, "operation_id", 120) + person_id = _identifier(person_id, "person_id") + actor_id = _identifier(actor_id, "actor_id", 160) + except ValueError: + return _result(False, "invalid_request") + if not isinstance(event, dict): + return _result(False, "invalid_p4_shadow_event", operation_id=operation_id, person_id=person_id) + for field in ("person_id", "origin_person_id"): + claimed = event.get(field) + if claimed not in (None, "", person_id): + return _result(False, "p4_shadow_person_mismatch", operation_id=operation_id, person_id=person_id) + normalized_event, event_errors = _normalize_p4_shadow_event(event) + if normalized_event is None: + return _result( + False, + "invalid_p4_shadow_event", + operation_id=operation_id, + person_id=person_id, + event_errors=event_errors, + ) + event_id = str(normalized_event["event_id"]) + payload = { + "person_id": person_id, + "actor_id": actor_id, + "event": normalized_event, + } + with _REGISTRY_LOCK: + root = self._root_copy() + repeated, fresh = _operation_result(root, operation_id, "record_p4_shadow_event", payload) + if repeated is not None: + return repeated + profile = root["profiles"].get(person_id) + if not isinstance(profile, dict): + return _result(False, "person_not_found", operation_id=operation_id, person_id=person_id) + if profile.get("person_id") != person_id: + return _result(False, "person_profile_conflict", operation_id=operation_id, person_id=person_id) + if profile.get("profile_status") != "active": + return _result(False, "person_not_active", operation_id=operation_id, person_id=person_id) + container = _p4_shadow_container(root) + people = container["people"] + entry = people.get(person_id) + if entry is None: + entry = _new_p4_shadow_person_entry(person_id, _now()) + current_state = deepcopy(entry["state"]) + event_index: dict[str, dict[str, Any]] = {} + else: + current_state, event_index, error = _replay_p4_shadow_entry(entry, person_id) + if error: + return _result(False, error, operation_id=operation_id, person_id=person_id) + assert current_state is not None and event_index is not None + known = event_index.get(event_id) + fingerprint = _p4_shadow_event_fingerprint(person_id, normalized_event) + if known is not None: + if known.get("event_fingerprint") != fingerprint: + return _result(False, "p4_shadow_event_id_conflict", operation_id=operation_id, person_id=person_id, event_id=event_id) + result = _result( + True, + "p4_shadow_event_duplicate", + operation_id=operation_id, + person_id=person_id, + origin_person_id=person_id, + event_id=event_id, + event_duplicate=True, + p4_shadow_summary=_p4_shadow_summary(current_state), + ) + _record_operation( + root, + operation_id=operation_id, + action="record_p4_shadow_event", + payload=payload, + metadata={"event_id": event_id, "origin_person_id": person_id, "duplicate_event": True}, + result=result, + now=_now(), + ) + self._commit(root) + return result + now = _now() + envelope = { + "event_id": event_id, + "person_id": person_id, + "origin_person_id": person_id, + "event": deepcopy(normalized_event), + "event_fingerprint": fingerprint, + "recorded_at": now, + "operation_id": operation_id, + } + entry["events"].append(envelope) + replay = replay_shadow_events([item["event"] for item in entry["events"]]) + replay_state = replay.get("state") if isinstance(replay, dict) else None + settlements = replay.get("settlements") if isinstance(replay, dict) else None + if not isinstance(replay_state, dict) or not isinstance(settlements, list): + return _result(False, "p4_shadow_replay_failed", operation_id=operation_id, person_id=person_id) + settlement = next( + (item for item in settlements if isinstance(item, dict) and item.get("event_id") == event_id), + None, + ) + if not isinstance(settlement, dict): + return _result(False, "p4_shadow_replay_failed", operation_id=operation_id, person_id=person_id) + entry["state"] = deepcopy(replay_state) + entry["updated_at"] = now + entry["last_operation_id"] = operation_id + people[person_id] = entry + result = _result( + True, + "p4_shadow_event_recorded", + operation_id=operation_id, + person_id=person_id, + origin_person_id=person_id, + event_id=event_id, + changed=True, + affected_person_ids=[person_id], + audit_event_id=operation_id, + event_outcome=str(settlement.get("outcome") or ""), + event_applied=bool(settlement.get("applied")), + p4_shadow_summary=_p4_shadow_summary(replay_state), + ) + _append_audit( + root, + operation_id=operation_id, + action="p4_shadow_event_recorded", + actor_id=actor_id, + code=result["code"], + now=now, + details={ + "person_id": person_id, + "origin_person_id": person_id, + "event_id": event_id, + "event_kind": str(normalized_event.get("kind") or "invalid"), + "event_outcome": result["event_outcome"], + "event_applied": result["event_applied"], + }, + ) + _record_operation( + root, + operation_id=operation_id, + action="record_p4_shadow_event", + payload=payload, + metadata={"event_id": event_id, "origin_person_id": person_id}, + result=result, + now=now, + ) + self._commit(root) + return result + def upsert_observed_identity( self, identity: dict[str, Any],