feat: add P3 orchestration and P4 shadow settlement
这个提交存在于:
父节点
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
普通文件
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
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
普通文件
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
普通文件
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),
|
||||
|
|
|
|||
1
tests/fixtures/context_orchestration_v1.json
Vendored
普通文件
1
tests/fixtures/context_orchestration_v1.json
Vendored
普通文件
|
|
@ -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
|
||||
113
tests/test_p4_capabilities.py
普通文件
113
tests/test_p4_capabilities.py
普通文件
|
|
@ -0,0 +1,113 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import annotations
|
||||
|
||||
import dataclasses
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
if str(ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from p4_capabilities import (
|
||||
P4_CAPABILITY_BY_ID,
|
||||
P4_CAPABILITY_REGISTRY,
|
||||
SAFE_EVENT_ID_RE,
|
||||
is_exact_p4_management_command,
|
||||
parse_p4_management_command,
|
||||
)
|
||||
|
||||
|
||||
PERSON_ID = "person_0123456789abcdef01234567"
|
||||
IDENTITY_KEY = "ops-origin-v1:" + ("a" * 64)
|
||||
EVENT_ID = "ledger:2026/07+owner@a.b-1"
|
||||
|
||||
|
||||
class P4CapabilityTests(unittest.TestCase):
|
||||
def test_exact_registered_forms_accept_only_stable_targets(self) -> None:
|
||||
cases = [
|
||||
(f"/放出 {PERSON_ID}", "p4.owner_release", PERSON_ID, "person_id", None),
|
||||
(f"/放出 {IDENTITY_KEY}", "p4.owner_release", IDENTITY_KEY, "p0_identity_key", None),
|
||||
(f"/误判 {PERSON_ID}", "p4.owner_misjudgment", PERSON_ID, "person_id", None),
|
||||
(f"/误判 {IDENTITY_KEY} {EVENT_ID}", "p4.owner_misjudgment", IDENTITY_KEY, "p0_identity_key", EVENT_ID),
|
||||
]
|
||||
for payload, capability_id, target, target_kind, event_id in cases:
|
||||
with self.subTest(payload=payload):
|
||||
parsed = parse_p4_management_command(payload)
|
||||
self.assertIsNotNone(parsed)
|
||||
assert parsed is not None
|
||||
self.assertEqual(parsed.capability_id, capability_id)
|
||||
self.assertEqual(parsed.target, target)
|
||||
self.assertEqual(parsed.target_kind, target_kind)
|
||||
self.assertEqual(parsed.event_id, event_id)
|
||||
self.assertTrue(is_exact_p4_management_command(payload))
|
||||
|
||||
def test_registry_metadata_is_immutable_and_explicitly_not_self_service(self) -> None:
|
||||
self.assertEqual(
|
||||
tuple(capability.capability_id for capability in P4_CAPABILITY_REGISTRY),
|
||||
("p4.owner_release", "p4.owner_misjudgment"),
|
||||
)
|
||||
self.assertEqual(set(P4_CAPABILITY_BY_ID), {"p4.owner_release", "p4.owner_misjudgment"})
|
||||
|
||||
for capability in P4_CAPABILITY_REGISTRY:
|
||||
with self.subTest(capability_id=capability.capability_id):
|
||||
self.assertEqual(capability.group, "p4_affinity_confinement")
|
||||
self.assertTrue(capability.tool.startswith("owner_"))
|
||||
self.assertTrue(capability.sensitivity.startswith("owner_only_"))
|
||||
self.assertTrue(capability.requires_owner_authorization)
|
||||
self.assertFalse(capability.self_service_allowed)
|
||||
self.assertEqual(capability.execution_mode, "shadow_advisory_only")
|
||||
with self.assertRaises(dataclasses.FrozenInstanceError):
|
||||
capability.tool = "unsafe" # type: ignore[misc]
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
P4_CAPABILITY_BY_ID["p4.appeal"] = P4_CAPABILITY_REGISTRY[0] # type: ignore[index]
|
||||
self.assertIsNone(parse_p4_management_command(f"/申诉 {PERSON_ID}"))
|
||||
self.assertIsNone(parse_p4_management_command(f"/appeal {PERSON_ID}"))
|
||||
|
||||
def test_malformed_mixed_or_nonpure_payload_never_matches(self) -> None:
|
||||
cases: list[object] = [
|
||||
None,
|
||||
1,
|
||||
"",
|
||||
"/放出",
|
||||
"/误判",
|
||||
f"/放出 {PERSON_ID} ",
|
||||
f" /放出 {PERSON_ID}",
|
||||
f"/放出 {PERSON_ID}",
|
||||
f"/放出\t{PERSON_ID}",
|
||||
f"/放出 {PERSON_ID}\n",
|
||||
f"请放出 /放出 {PERSON_ID}",
|
||||
f"/放出 {PERSON_ID} 谢谢",
|
||||
f"/误判 {PERSON_ID} {EVENT_ID} 请立即执行",
|
||||
f"/误判 {PERSON_ID} {EVENT_ID} extra",
|
||||
f"/误判 {PERSON_ID}\n{EVENT_ID}",
|
||||
f"/误判 {PERSON_ID} {EVENT_ID}",
|
||||
f"/未知 {PERSON_ID}",
|
||||
"/放出 alice",
|
||||
"/放出 12345678",
|
||||
"/放出 person_0123456789abcdef0123456g",
|
||||
"/放出 person_0123456789abcdef012345678",
|
||||
"/放出 ops-origin-v1:" + ("A" * 64),
|
||||
f"/误判 {PERSON_ID} _bad-event",
|
||||
f"/误判 {PERSON_ID} bad event",
|
||||
f"/误判 {PERSON_ID} " + ("a" * 129),
|
||||
f"/放出 {PERSON_ID}; /误判 {PERSON_ID}",
|
||||
]
|
||||
for payload in cases:
|
||||
with self.subTest(payload=payload):
|
||||
self.assertIsNone(parse_p4_management_command(payload))
|
||||
self.assertFalse(is_exact_p4_management_command(payload))
|
||||
|
||||
def test_event_id_grammar_matches_the_p4_engine_safe_identifier_contract(self) -> None:
|
||||
self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch(EVENT_ID))
|
||||
self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch("A"))
|
||||
self.assertIsNotNone(SAFE_EVENT_ID_RE.fullmatch("a" * 128))
|
||||
self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("a" * 129))
|
||||
self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("_starts_wrong"))
|
||||
self.assertIsNone(SAFE_EVENT_ID_RE.fullmatch("has whitespace"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
155
tests/test_p4_joint_workspace.py
普通文件
155
tests/test_p4_joint_workspace.py
普通文件
|
|
@ -0,0 +1,155 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""P4-A cross-repository acceptance harness for the checked-out workspace.
|
||||
|
||||
This test intentionally verifies the producer/consumer boundary rather than
|
||||
teaching the memory plugin P4 business rules. It requires the documented
|
||||
sibling repository layout and is a local-workspace acceptance test.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from copy import deepcopy
|
||||
from dataclasses import fields
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from context_orchestration import (
|
||||
FINALIZE,
|
||||
contract_descriptor as companion_p3_descriptor,
|
||||
contract_fingerprint as companion_p3_fingerprint,
|
||||
)
|
||||
from unified_person_contract import (
|
||||
CONTRACT_FINGERPRINT as COMPANION_P0_FINGERPRINT,
|
||||
build_person_projection,
|
||||
empty_unified_person_store,
|
||||
)
|
||||
from unified_person_registry import UnifiedPersonRegistry
|
||||
|
||||
|
||||
WORKSPACE_ROOT = Path(__file__).resolve().parents[2]
|
||||
MEMORY_ROOT = WORKSPACE_ROOT / "astrbot_plugin_memory_companion-main"
|
||||
if str(MEMORY_ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(MEMORY_ROOT))
|
||||
|
||||
from core import context_orchestration as memory_p3 # noqa: E402
|
||||
from core.bridge import MemoryCompanionBridge # noqa: E402
|
||||
from core.models import MemoryRecord, SessionContext # noqa: E402
|
||||
from core.service import MemoryCompanionService # noqa: E402
|
||||
from core.unified_person_contract import contract_fingerprint as memory_p0_fingerprint # noqa: E402
|
||||
|
||||
|
||||
P0_FINGERPRINT = "633e2d235345d5c1bb72f8e6247e61932c5215ad2817242eefb709b502aefe03"
|
||||
P3_FINGERPRINT = "3bb7a12af05bb4d9a47cef9f31e78752cec512b90b1d50ae49feef54470974f8"
|
||||
P4_STATE_FIELDS = {
|
||||
"affinity_score",
|
||||
"affinity_band",
|
||||
"warning_stage",
|
||||
"confinement_state",
|
||||
"confinement_until",
|
||||
"confinement_round",
|
||||
"release_prompt_pending",
|
||||
}
|
||||
|
||||
|
||||
@unittest.skipUnless(MEMORY_ROOT.is_dir(), "P4 joint workspace requires the memory companion sibling repository")
|
||||
class P4JointWorkspaceTests(unittest.TestCase):
|
||||
def test_p4_shadow_ledger_stays_companion_only_and_p0_p3_contracts_do_not_drift(self):
|
||||
self.assertEqual(COMPANION_P0_FINGERPRINT, P0_FINGERPRINT)
|
||||
self.assertEqual(memory_p0_fingerprint(), P0_FINGERPRINT)
|
||||
self.assertEqual(companion_p3_descriptor(), memory_p3.contract_descriptor())
|
||||
self.assertEqual(companion_p3_fingerprint(), P3_FINGERPRINT)
|
||||
self.assertEqual(memory_p3.contract_fingerprint(), P3_FINGERPRINT)
|
||||
self.assertEqual(FINALIZE, -22000)
|
||||
|
||||
observed_identity = {
|
||||
"companion_instance_id": "companion-a",
|
||||
"bot_account_id": "bot-a",
|
||||
"adapter_instance_id": "telegram-main",
|
||||
"subject_namespace": "telegram.user",
|
||||
"platform_subject_id": "42",
|
||||
}
|
||||
explicitly_linked_identity = {
|
||||
**observed_identity,
|
||||
"bot_account_id": "bot-b",
|
||||
}
|
||||
store = {"unified_person": empty_unified_person_store()}
|
||||
registry = UnifiedPersonRegistry(store)
|
||||
created = registry.upsert_observed_identity(
|
||||
observed_identity,
|
||||
operation_id="p4-joint-observe",
|
||||
display_name="joint-user",
|
||||
)
|
||||
self.assertTrue(created["ok"])
|
||||
person_id = created["person_id"]
|
||||
self.assertTrue(registry.link_identity(
|
||||
explicitly_linked_identity,
|
||||
person_id,
|
||||
operation_id="p4-joint-link",
|
||||
actor_id="joint_test",
|
||||
reason="p4_joint_exact_identity",
|
||||
authorized=True,
|
||||
)["ok"])
|
||||
self.assertTrue(registry.unlink_identity(
|
||||
observed_identity,
|
||||
operation_id="p4-joint-unlink",
|
||||
actor_id="joint_test",
|
||||
reason="p4_joint_exact_identity",
|
||||
authorized=True,
|
||||
)["ok"])
|
||||
projection_before = build_person_projection(store, person_id)
|
||||
self.assertIsNotNone(projection_before)
|
||||
assert projection_before is not None
|
||||
self.assertEqual(projection_before["identity_assurance"], "explicit_linked")
|
||||
profile_before = deepcopy(store["unified_person"]["profiles"][person_id])
|
||||
|
||||
shadow = registry.record_p4_shadow_event(
|
||||
person_id,
|
||||
{
|
||||
"event_id": "p4-joint-normal-1",
|
||||
"occurred_at": "2026-07-29T00:00:00Z",
|
||||
"kind": "normal",
|
||||
},
|
||||
operation_id="p4-joint-record-1",
|
||||
actor_id="p4_joint_harness",
|
||||
)
|
||||
self.assertTrue(shadow["ok"])
|
||||
self.assertEqual(shadow["p4_shadow_summary"]["score"], 0)
|
||||
self.assertEqual(store["unified_person"]["profiles"][person_id], profile_before)
|
||||
self.assertEqual(build_person_projection(store, person_id), projection_before)
|
||||
self.assertNotIn("p4_shadow", projection_before)
|
||||
self.assertEqual(len(store["unified_person"]["p4_shadow"]["people"][person_id]["events"]), 1)
|
||||
|
||||
service = MemoryCompanionService.__new__(MemoryCompanionService)
|
||||
bridge = MemoryCompanionBridge(service)
|
||||
context = bridge._trusted_session_context(
|
||||
{
|
||||
"session_id": "private:42",
|
||||
"scope": "private",
|
||||
"unified_person_projection": projection_before,
|
||||
"unified_person_source_identity": explicitly_linked_identity,
|
||||
}
|
||||
)
|
||||
self.assertIsInstance(context, SessionContext)
|
||||
self.assertEqual(context.person_id, person_id)
|
||||
self.assertEqual(context.person_origin_identity_key, projection_before["resolved_identity_key"])
|
||||
self.assertEqual(context.person_identity_assurance, "explicit_linked")
|
||||
self.assertTrue(P4_STATE_FIELDS.isdisjoint(item.name for item in fields(SessionContext)))
|
||||
self.assertTrue(P4_STATE_FIELDS.isdisjoint(item.name for item in fields(MemoryRecord)))
|
||||
|
||||
forged_projection = deepcopy(projection_before)
|
||||
forged_projection["affinity_score"] = -1201
|
||||
rejected = service.session_context_from_bridge(
|
||||
{
|
||||
"session_id": "private:42",
|
||||
"scope": "private",
|
||||
"unified_person_projection": forged_projection,
|
||||
"unified_person_source_identity": explicitly_linked_identity,
|
||||
}
|
||||
)
|
||||
self.assertEqual(rejected.person_id, "")
|
||||
self.assertEqual(rejected.person_origin_identity_key, "")
|
||||
self.assertEqual(rejected.person_identity_assurance, "")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
243
tests/test_p4_shadow_hook.py
普通文件
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()
|
||||
249
tests/test_p4_shadow_registry.py
普通文件
249
tests/test_p4_shadow_registry.py
普通文件
|
|
@ -0,0 +1,249 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import annotations
|
||||
|
||||
from copy import deepcopy
|
||||
import importlib
|
||||
import pathlib
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
|
||||
from unified_person_contract import build_person_projection, empty_unified_person_store
|
||||
from unified_person_registry import UnifiedPersonRegistry
|
||||
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
|
||||
import _host_stub # noqa: E402
|
||||
|
||||
_host_stub.install()
|
||||
|
||||
_PACKAGE_NAME = "_p4_shadow_registry_companion"
|
||||
if _PACKAGE_NAME not in sys.modules:
|
||||
package = types.ModuleType(_PACKAGE_NAME)
|
||||
package.__path__ = [str(pathlib.Path(__file__).resolve().parents[1])]
|
||||
sys.modules[_PACKAGE_NAME] = package
|
||||
|
||||
core_store_module = importlib.import_module(f"{_PACKAGE_NAME}.core_store")
|
||||
|
||||
|
||||
def identity(subject_id: str) -> dict[str, str]:
|
||||
return {
|
||||
"companion_instance_id": "companion-a",
|
||||
"bot_account_id": "bot-1",
|
||||
"adapter_instance_id": "telegram-main",
|
||||
"subject_namespace": "telegram.user",
|
||||
"platform_subject_id": subject_id,
|
||||
}
|
||||
|
||||
|
||||
def normal_event(event_id: str, *, occurred_at: str = "2026-07-29T00:00:00Z") -> dict[str, str]:
|
||||
return {
|
||||
"event_id": event_id,
|
||||
"occurred_at": occurred_at,
|
||||
"kind": "normal",
|
||||
}
|
||||
|
||||
|
||||
def violation_event(event_id: str) -> dict:
|
||||
return {
|
||||
"event_id": event_id,
|
||||
"occurred_at": "2026-07-29T00:00:00Z",
|
||||
"kind": "violation",
|
||||
"review": {
|
||||
"schema_version": "p4.review.v1",
|
||||
"verdict": "violation",
|
||||
"category": "prompt_injection",
|
||||
"confidence": 0.95,
|
||||
"risk_flags": [],
|
||||
"evidence": [{
|
||||
"message_id": "message-p4-1",
|
||||
"code": "direct_instruction_override",
|
||||
"source": "current_message",
|
||||
}],
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
class _CoreStoreHost(core_store_module.CoreStoreMixin):
|
||||
def __init__(self, data: dict) -> None:
|
||||
self.data = data
|
||||
self.save_calls = 0
|
||||
|
||||
def _schedule_data_save(self) -> None:
|
||||
self.save_calls += 1
|
||||
|
||||
|
||||
class P4ShadowRegistryTests(unittest.TestCase):
|
||||
def setUp(self) -> None:
|
||||
self.store = {"unified_person": empty_unified_person_store()}
|
||||
self.registry = UnifiedPersonRegistry(self.store)
|
||||
|
||||
def _observe(self, subject_id: str = "42") -> str:
|
||||
result = self.registry.upsert_observed_identity(
|
||||
identity(subject_id),
|
||||
operation_id=f"observe-{subject_id}",
|
||||
display_name=f"user-{subject_id}",
|
||||
)
|
||||
self.assertTrue(result["ok"])
|
||||
return result["person_id"]
|
||||
|
||||
def test_shadow_event_is_persisted_under_additive_container_only(self):
|
||||
person_id = self._observe()
|
||||
before_profile = deepcopy(self.store["unified_person"]["profiles"][person_id])
|
||||
before_projection = build_person_projection(self.store, person_id)
|
||||
|
||||
result = self.registry.record_p4_shadow_event(
|
||||
person_id,
|
||||
normal_event("p4-event-1"),
|
||||
operation_id="p4-operation-1",
|
||||
actor_id="system",
|
||||
)
|
||||
|
||||
self.assertTrue(result["ok"])
|
||||
self.assertTrue(result["changed"])
|
||||
self.assertEqual(result["code"], "p4_shadow_event_recorded")
|
||||
self.assertEqual(result["event_id"], "p4-event-1")
|
||||
self.assertEqual(self.store["unified_person"]["profiles"][person_id], before_profile)
|
||||
self.assertEqual(build_person_projection(self.store, person_id), before_projection)
|
||||
shadow = self.store["unified_person"]["p4_shadow"]
|
||||
entry = shadow["people"][person_id]
|
||||
self.assertEqual(entry["person_id"], person_id)
|
||||
self.assertEqual(entry["origin_person_id"], person_id)
|
||||
self.assertEqual(entry["events"][0]["person_id"], person_id)
|
||||
self.assertEqual(entry["events"][0]["origin_person_id"], person_id)
|
||||
self.assertEqual(entry["events"][0]["event"]["event_id"], "p4-event-1")
|
||||
self.assertEqual(entry["state"]["score"], 0)
|
||||
self.assertEqual(entry["state"]["event_log"][0]["event_id"], "p4-event-1")
|
||||
|
||||
read = self.registry.read_p4_shadow_state(person_id)
|
||||
self.assertTrue(read["ok"])
|
||||
self.assertTrue(read["p4_shadow_exists"])
|
||||
self.assertEqual(read["p4_shadow_state"], entry["state"])
|
||||
audit = self.registry.audit_events()
|
||||
self.assertEqual(audit[-1]["action"], "p4_shadow_event_recorded")
|
||||
self.assertEqual(audit[-1]["details"]["origin_person_id"], person_id)
|
||||
|
||||
def test_registry_uses_pure_engine_for_violation_shadow_without_profile_projection_write(self):
|
||||
person_id = self._observe()
|
||||
before_profile = deepcopy(self.store["unified_person"]["profiles"][person_id])
|
||||
before_projection = build_person_projection(self.store, person_id)
|
||||
|
||||
result = self.registry.record_p4_shadow_event(
|
||||
person_id,
|
||||
violation_event("p4-event-violation"),
|
||||
operation_id="p4-operation-violation",
|
||||
actor_id="reviewer",
|
||||
)
|
||||
|
||||
self.assertTrue(result["ok"])
|
||||
self.assertTrue(result["event_applied"])
|
||||
self.assertEqual(result["p4_shadow_summary"]["score"], -400)
|
||||
entry = self.store["unified_person"]["p4_shadow"]["people"][person_id]
|
||||
self.assertEqual(entry["state"]["score"], -400)
|
||||
self.assertEqual(entry["events"][0]["event"]["review"]["category"], "prompt_injection")
|
||||
self.assertNotIn("severity_steps", entry["events"][0]["event"]["review"])
|
||||
self.assertEqual(self.store["unified_person"]["profiles"][person_id], before_profile)
|
||||
self.assertEqual(build_person_projection(self.store, person_id), before_projection)
|
||||
|
||||
def test_event_and_operation_idempotence_conflicts_do_not_replay_or_overwrite(self):
|
||||
person_id = self._observe()
|
||||
event = normal_event("p4-event-idempotent")
|
||||
first = self.registry.record_p4_shadow_event(
|
||||
person_id, event, operation_id="p4-operation-idempotent", actor_id="system",
|
||||
)
|
||||
self.assertTrue(first["ok"])
|
||||
after_first = deepcopy(self.store)
|
||||
|
||||
repeated = self.registry.record_p4_shadow_event(
|
||||
person_id, event, operation_id="p4-operation-idempotent", actor_id="system",
|
||||
)
|
||||
self.assertTrue(repeated["ok"])
|
||||
self.assertTrue(repeated["idempotent"])
|
||||
self.assertEqual(self.store, after_first)
|
||||
|
||||
duplicate = self.registry.record_p4_shadow_event(
|
||||
person_id, event, operation_id="p4-operation-new", actor_id="system",
|
||||
)
|
||||
self.assertTrue(duplicate["ok"])
|
||||
self.assertEqual(duplicate["code"], "p4_shadow_event_duplicate")
|
||||
self.assertFalse(duplicate["changed"])
|
||||
self.assertTrue(duplicate["event_duplicate"])
|
||||
entry = self.store["unified_person"]["p4_shadow"]["people"][person_id]
|
||||
self.assertEqual(len(entry["events"]), 1)
|
||||
self.assertEqual(len(self.registry.audit_events()), 2) # observed identity plus initial P4 event
|
||||
after_duplicate = deepcopy(self.store)
|
||||
|
||||
event_conflict = self.registry.record_p4_shadow_event(
|
||||
person_id,
|
||||
normal_event("p4-event-idempotent", occurred_at="2026-07-30T00:00:00Z"),
|
||||
operation_id="p4-operation-event-conflict",
|
||||
actor_id="system",
|
||||
)
|
||||
self.assertEqual(event_conflict["code"], "p4_shadow_event_id_conflict")
|
||||
self.assertEqual(self.store, after_duplicate)
|
||||
|
||||
operation_conflict = self.registry.record_p4_shadow_event(
|
||||
person_id,
|
||||
normal_event("p4-event-other"),
|
||||
operation_id="p4-operation-idempotent",
|
||||
actor_id="system",
|
||||
)
|
||||
self.assertEqual(operation_conflict["code"], "operation_id_conflict")
|
||||
self.assertEqual(self.store, after_duplicate)
|
||||
|
||||
def test_unknown_inactive_and_mismatched_origin_are_rejected_without_shadow_writes(self):
|
||||
before_unknown = deepcopy(self.store)
|
||||
unknown = self.registry.record_p4_shadow_event(
|
||||
"person_missing", normal_event("p4-event-unknown"), operation_id="p4-operation-unknown", actor_id="system",
|
||||
)
|
||||
self.assertEqual(unknown["code"], "person_not_found")
|
||||
self.assertEqual(self.store, before_unknown)
|
||||
|
||||
person_id = self._observe()
|
||||
before_mismatch = deepcopy(self.store)
|
||||
mismatch = self.registry.record_p4_shadow_event(
|
||||
person_id,
|
||||
{**normal_event("p4-event-mismatch"), "origin_person_id": "person_other"},
|
||||
operation_id="p4-operation-mismatch",
|
||||
actor_id="system",
|
||||
)
|
||||
self.assertEqual(mismatch["code"], "p4_shadow_person_mismatch")
|
||||
self.assertEqual(self.store, before_mismatch)
|
||||
|
||||
self.store["unified_person"]["profiles"][person_id]["profile_status"] = "suspended"
|
||||
before_inactive = deepcopy(self.store)
|
||||
inactive = self.registry.record_p4_shadow_event(
|
||||
person_id, normal_event("p4-event-inactive"), operation_id="p4-operation-inactive", actor_id="system",
|
||||
)
|
||||
self.assertEqual(inactive["code"], "person_not_active")
|
||||
self.assertEqual(self.store, before_inactive)
|
||||
read_inactive = self.registry.read_p4_shadow_state(person_id)
|
||||
self.assertEqual(read_inactive["code"], "person_not_active")
|
||||
|
||||
def test_core_store_whitelist_persists_only_non_idempotent_successes(self):
|
||||
person_id = self._observe()
|
||||
host = _CoreStoreHost(self.store)
|
||||
event = normal_event("p4-event-core-store")
|
||||
|
||||
first = host._apply_unified_person_lifecycle(
|
||||
"record_p4_shadow_event", person_id, event, operation_id="p4-operation-core-store", actor_id="system",
|
||||
)
|
||||
self.assertTrue(first["ok"])
|
||||
self.assertEqual(host.save_calls, 1)
|
||||
repeated = host._apply_unified_person_lifecycle(
|
||||
"record_p4_shadow_event", person_id, event, operation_id="p4-operation-core-store", actor_id="system",
|
||||
)
|
||||
self.assertTrue(repeated["idempotent"])
|
||||
self.assertEqual(host.save_calls, 1)
|
||||
duplicate = host._apply_unified_person_lifecycle(
|
||||
"record_p4_shadow_event", person_id, event, operation_id="p4-operation-core-store-duplicate", actor_id="system",
|
||||
)
|
||||
self.assertEqual(duplicate["code"], "p4_shadow_event_duplicate")
|
||||
self.assertEqual(host.save_calls, 2)
|
||||
unsupported = host._apply_unified_person_lifecycle("read_p4_shadow_state", person_id)
|
||||
self.assertEqual(unsupported["code"], "unsupported_lifecycle_operation")
|
||||
self.assertEqual(host.save_calls, 2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
@ -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],
|
||||
|
|
|
|||
正在加载…
添加表格
在新工单中引用