feat: add P3 orchestration and P4 shadow settlement

这个提交存在于:
YokiiroBW 2026-07-29 21:32:53 +08:00
父节点 2d4d6a7cb8
当前提交 23c57cc84f
共有 17 个文件被更改,包括 2984 次插入 和 16 次删除

查看文件

@ -157,6 +157,14 @@ openid=主用户ID
- 插件不会仅凭昵称自动合并身份。
- “主要用户”会获得插件管理权限,但权限只认真实发送者 ID;身份别名不会把另一个发送者一并提升为管理员。
### P4-A 影子账本(默认关闭)
当前开发阶段提供 enable_p4_shadow_observer 开关,默认关闭。开启后,插件只会在 P3 安全编排完成后,为具备精确、已验证或显式关联身份且拥有稳定消息 ID 的会话写入独立影子账本。
- 影子账本不会修改现有 relationship_score、人物投影、忽略门、普通 LLM 回复或任何实际管理命令结果。
- 消息正文不写入 P4 账本;稳定消息 ID 仅以摘要形式用于幂等审计。
- 好感实时加减、警告、禁闭、释放语、恢复消费和 owner 命令执行均未启用,仍须等待后续 P4-B 授权和验收。
## 核心工作方式
### 被动回复

192
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"

查看文件

@ -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)

230
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 标签。"""

查看文件

@ -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)))

963
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

153
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>{_TARGET})\Z")
_MISJUDGMENT_RE = re.compile(
rf"/误判 (?P<target>{_TARGET})(?: (?P<event_id>{_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

查看文件

@ -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),

查看文件

@ -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}}

查看文件

@ -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()

查看文件

@ -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()

查看文件

@ -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

查看文件

@ -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()

查看文件

@ -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()

243
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()

查看文件

@ -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()

查看文件

@ -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],