diff --git a/_conf_schema.json b/_conf_schema.json
index 9ed69d0..e089d97 100644
--- a/_conf_schema.json
+++ b/_conf_schema.json
@@ -10,6 +10,12 @@
"hint": "默认关闭。开启后,本插件只保留主动私聊的日程、生成和发送链路;普通私聊/群聊消息不会再进入本插件的被动增强、图片/转发处理、防抖、群聊观察、TTS 后处理或提示词注入,但不会阻止 AstrBot 默认回复或其他插件处理。用户回复本插件主动消息时仍会轻量记录为已回应。适合只想使用主动陪伴,或担心本插件被动链路误接管、误识别的场景。",
"default": false
},
+ "enable_p4_b_legacy_score_isolation": {
+ "description": "Isolate legacy relationship score writes",
+ "type": "bool",
+ "hint": "Disabled by default for compatibility. When enabled, legacy relationship_score writes are suppressed and never become P4 authority.",
+ "default": false
+ },
"bot_name": {
"description": "Bot 名字 / 页面展示名",
"type": "string",
diff --git a/main.py b/main.py
index 604e923..032c26e 100644
--- a/main.py
+++ b/main.py
@@ -136,6 +136,11 @@ from .person_context_contract import (
from .unified_person_registry import UnifiedPersonRegistry
from .context_orchestration import build_context, project_context
from .p4_shadow import build_p4_shadow
+from .p4_affinity_confinement import apply_legacy_relationship_delta
+from .p4_live_runtime import decide_live_request
+from .p4_runtime_gate import SAFE_CONFINEMENT_REPLY
+from .p6_readonly_projection import build_p6_readonly_status
+from .reply_temperature import compose_reply_temperature
from .plugin_identity import (
PLUGIN_ID,
PLUGIN_VERSION,
@@ -395,6 +400,13 @@ class PrivateCompanionExtensionAPI:
def get_unified_person_projection(self, person_id: str) -> dict[str, Any] | None:
return self._plugin.get_unified_person_projection(person_id)
+ def get_p6_readonly_status(self) -> dict[str, Any]:
+ """Expose bounded Unified Person counts without an authority surface."""
+ try:
+ return build_p6_readonly_status(self._plugin._unified_person_registry_status())
+ except Exception:
+ return build_p6_readonly_status(None)
+
def get_unified_person_context(self, event: Any | None = None) -> dict[str, Any]:
return self._plugin.build_unified_person_context(event)
@@ -1275,6 +1287,7 @@ class PrivateCompanionPlugin(
self._legacy_enabled_config_disabled = legacy_enabled_value is False
# 插件启停只交给 AstrBot 官方插件开关;旧版配置里的 enabled 已废弃,避免残留 false 误关整套链路。
self.enabled = True
+ self.enable_p4_b_legacy_score_isolation = self._cfg_bool(c, "enable_p4_b_legacy_score_isolation", False)
self.enable_proactive_only_mode = self._cfg_bool(c, "enable_proactive_only_mode", False)
self.proactive_intensity_preset = self._normalize_proactive_intensity_preset(
self._cfg_str(c, "proactive_intensity_preset", "off", "off")
@@ -2413,6 +2426,9 @@ class PrivateCompanionPlugin(
"registry": self.unified_person_registry.status(),
}
+ def _unified_person_registry_status(self) -> dict[str, Any]:
+ return self.unified_person_registry.status()
+
def _unified_person_event_identity(
self,
event: Any | None = None,
@@ -2491,6 +2507,106 @@ class PrivateCompanionPlugin(
def get_unified_person_projection(self, person_id: str) -> dict[str, Any] | None:
return self.unified_person_registry.read_projection(person_id)
+ def read_p4_effect_state(self, person_id: str) -> dict[str, Any]:
+ return self.unified_person_registry.read_p4_effect_state(person_id)
+
+ def read_p4_live_state(self, person_id: str) -> dict[str, Any]:
+ return self.unified_person_registry.read_p4_live_state(person_id)
+
+ def _p4_b_apply_legacy_relationship_delta(self, user: dict[str, Any], delta: int, *, reason_code: str = "") -> bool:
+ del reason_code
+ return apply_legacy_relationship_delta(
+ user,
+ delta,
+ isolate=bool(getattr(self, "enable_p4_b_legacy_score_isolation", False)),
+ )
+
+ def _p4_live_state_for_event(self, event: Any) -> dict[str, Any] | None:
+ try:
+ if not bool(event.is_private_chat()):
+ return None
+ except Exception:
+ return None
+ resolution = self.resolve_unified_person_for_event(event)
+ if resolution.get("state") != "resolved":
+ return None
+ person_id = _single_line(resolution.get("person_id"), 160)
+ if not person_id:
+ return None
+ result = self.read_p4_live_state(person_id)
+ if result.get("ok") is not True:
+ return {"_p4_live_invalid": True}
+ return result.get("state")
+
+ def _bounded_p4_reply_temperature_signals(self, event: Any) -> dict[str, Any]:
+ """Return transient, bounded advisory inputs for the P4 reply projection."""
+ data = getattr(self, "data", None)
+ daily_state = data.get("daily_state") if isinstance(data, dict) else None
+ energy = daily_state.get("energy") if isinstance(daily_state, dict) else None
+ if (
+ isinstance(energy, bool)
+ or not isinstance(energy, (int, float))
+ or not math.isfinite(float(energy))
+ ):
+ energy = None
+ else:
+ energy = max(0, min(100, energy))
+ mood = ""
+ if isinstance(daily_state, dict):
+ mood = _single_line(daily_state.get("mood_bias") or daily_state.get("mood"), 64)
+
+ schedule_parts: list[str] = []
+ segment_getter = getattr(self, "_current_detail_segment_for_update", None)
+ if callable(segment_getter):
+ try:
+ segment = segment_getter()
+ except Exception:
+ segment = None
+ if isinstance(segment, dict):
+ schedule_parts.extend(
+ _single_line(segment.get(key), 80)
+ for key in ("title", "name", "summary", "activity", "location")
+ if _single_line(segment.get(key), 80)
+ )
+ if not schedule_parts and isinstance(data, dict):
+ try:
+ current_item = self._get_current_plan_item(data.get("daily_plan", {}))
+ except Exception:
+ current_item = None
+ if isinstance(current_item, dict):
+ schedule_parts.extend(
+ _single_line(current_item.get(key), 80)
+ for key in ("title", "name", "summary", "activity", "location")
+ if _single_line(current_item.get(key), 80)
+ )
+
+ return {
+ "energy": energy,
+ "mood": mood or None,
+ "schedule": " ".join(schedule_parts)[:240] or None,
+ "context": _single_line(getattr(event, "message_str", ""), 280) or None,
+ }
+
+ def record_p4_effect_event(
+ self,
+ person_id: str,
+ event: dict[str, Any],
+ *,
+ operation_id: str,
+ actor_id: str = "system",
+ ) -> dict[str, Any]:
+ result = self.unified_person_registry.record_p4_effect_event(
+ person_id,
+ event,
+ operation_id=operation_id,
+ actor_id=actor_id,
+ )
+ if result.get("ok") and result.get("changed"):
+ saver = getattr(self, "_schedule_data_save", None)
+ if callable(saver):
+ saver()
+ return result
+
def resolve_unified_person_for_event(self, event: Any | None = None) -> dict[str, Any]:
identity = self._unified_person_event_identity(event)
if not identity:
@@ -8972,7 +9088,7 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
str(user.get("last_proactive_action") or "message"),
text,
)
- user["relationship_score"] = _safe_int(user.get("relationship_score"), 0) + 2
+ self._p4_b_apply_legacy_relationship_delta(user, 2, reason_code="proactive_reply")
user["awaiting_reply_since"] = 0
user["last_reply_at"] = received_ts
user["last_private_reply_at"] = received_ts
@@ -9227,6 +9343,52 @@ 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=-30000)
+ async def enforce_p4_live_confinement_before_enrichment(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs):
+ """Block only an already-resolved private person with an invalid or active P4 state."""
+ if self is None or req is None or not bool(getattr(self, "enabled", False)):
+ return
+ state = self._p4_live_state_for_event(event)
+ decision = decide_live_request(state)
+ if decision.get("decision") == "skip":
+ return
+ if decision.get("decision") == "block":
+ # This runs before P5/Memory and the enrichment collectors. Leave
+ # no request route to original prompt, tool, bridge, or context data.
+ for attribute, value in (
+ ("system_prompt", SAFE_CONFINEMENT_REPLY),
+ ("prompt", ""),
+ ("contexts", []),
+ ("extra_user_content_parts", []),
+ ("func_tool", None),
+ ("tools", []),
+ ("images", []),
+ ("image_urls", []),
+ ):
+ try:
+ setattr(req, attribute, value)
+ except Exception:
+ pass
+ try:
+ setattr(event, "private_companion_p4_blocked", True)
+ setattr(event, "private_companion_p4_block_code", decision.get("code", "p4_state_invalid"))
+ except Exception:
+ pass
+ await self._reply(event, SAFE_CONFINEMENT_REPLY)
+ event.stop_event()
+ return
+ temperature = compose_reply_temperature(
+ decision.get("warmth_projection", {}).get("tier"),
+ **self._bounded_p4_reply_temperature_signals(event),
+ )
+ try:
+ setattr(req, "_private_companion_reply_temperature", temperature)
+ except Exception:
+ pass
+ instruction = _single_line(temperature.get("instruction"), 240)
+ if instruction and hasattr(req, "system_prompt"):
+ req.system_prompt = f"{str(getattr(req, 'system_prompt', '') or '').rstrip()}\n\n[Reply boundary]\n{instruction}"
+
@filter.on_llm_request(priority=-22000)
async def prepare_p5_memory_attestation(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs):
"""Expose a per-request attestation issuer before MemoryCompanion runs."""
@@ -11868,7 +12030,7 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
)
rest_silence_applied = self._apply_user_rest_silence_from_message(fast_user, safe_text or text, now=received_ts)
fast_user["inbound_count"] = _safe_int(fast_user.get("inbound_count"), 0) + 1
- fast_user["relationship_score"] = _safe_int(fast_user.get("relationship_score"), 0) + 1
+ self._p4_b_apply_legacy_relationship_delta(fast_user, 1, reason_code="fast_inbound")
fast_user["episode_message_count"] = _safe_int(fast_user.get("episode_message_count"), 0, 0) + 1
if _safe_float(fast_user.get("awaiting_reply_since"), 0) > 0:
fast_user["reply_count"] = _safe_int(fast_user.get("reply_count"), 0) + 1
@@ -11877,7 +12039,7 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
str(fast_user.get("last_proactive_action") or "message"),
text,
)
- fast_user["relationship_score"] = _safe_int(fast_user.get("relationship_score"), 0) + 2
+ self._p4_b_apply_legacy_relationship_delta(fast_user, 2, reason_code="fast_proactive_reply")
fast_user["awaiting_reply_since"] = 0
fast_user["last_reply_at"] = received_ts
fast_user["last_private_reply_at"] = received_ts
@@ -11890,7 +12052,7 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
if fast_user_is_owner:
self._handle_meal_care_inbound(fast_user, safe_text or text, now=received_ts)
if fast_user_is_owner and self._apply_interaction_warmth_to_state(text, fast_user):
- fast_user["relationship_score"] = _safe_int(fast_user.get("relationship_score"), 0) + 1
+ self._p4_b_apply_legacy_relationship_delta(fast_user, 1, reason_code="fast_interaction_warmth")
self._schedule_data_save()
if (
rest_silence_applied
@@ -12206,7 +12368,7 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
self._note_morning_greeting_reply(user, now=received_ts or _now_ts())
if text:
user["inbound_count"] = _safe_int(user.get("inbound_count"), 0) + 1
- user["relationship_score"] = _safe_int(user.get("relationship_score"), 0) + 1
+ self._p4_b_apply_legacy_relationship_delta(user, 1, reason_code="inbound")
suspended = user.get("suspended_proactive")
if (
isinstance(suspended, dict)
@@ -12226,7 +12388,7 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
str(user.get("last_proactive_action") or "message"),
text,
)
- user["relationship_score"] = _safe_int(user.get("relationship_score"), 0) + 2
+ self._p4_b_apply_legacy_relationship_delta(user, 2, reason_code="proactive_reply")
user["awaiting_reply_since"] = 0
user["last_reply_at"] = _now_ts()
user["last_private_reply_at"] = user["last_reply_at"]
@@ -12333,10 +12495,10 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
}
care_feedback_applied = bool(text) and user_is_owner and self._apply_care_feedback_to_state(text)
if care_feedback_applied:
- user["relationship_score"] = _safe_int(user.get("relationship_score"), 0) + 2
+ self._p4_b_apply_legacy_relationship_delta(user, 2, reason_code="care_feedback")
interaction_warmth_applied = bool(text) and is_target_user and user_is_owner and self._apply_interaction_warmth_to_state(text, user)
if interaction_warmth_applied:
- user["relationship_score"] = _safe_int(user.get("relationship_score"), 0) + 1
+ self._p4_b_apply_legacy_relationship_delta(user, 1, reason_code="interaction_warmth")
schedule_adjustment_applied = (
bool(text)
and is_target_user
@@ -12344,9 +12506,9 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
and self._record_schedule_adjustment_from_interaction(text, user)
)
if schedule_adjustment_applied:
- user["relationship_score"] = _safe_int(user.get("relationship_score"), 0) + 1
+ self._p4_b_apply_legacy_relationship_delta(user, 1, reason_code="schedule_adjustment")
if food_feedback_applied:
- user["relationship_score"] = _safe_int(user.get("relationship_score"), 0) + 1
+ self._p4_b_apply_legacy_relationship_delta(user, 1, reason_code="food_feedback")
response = ""
if is_target_user:
diff --git a/memory_companion_adapter.py b/memory_companion_adapter.py
index 48dd8e5..eea1474 100644
--- a/memory_companion_adapter.py
+++ b/memory_companion_adapter.py
@@ -2305,3 +2305,55 @@ class MemoryCompanionAdapterMixin:
except Exception as exc:
self._memory_companion_optional_dependency_failed(exc, where="get_relationship_phase")
return {"phase": "unknown", "momentum": 0.0}
+
+ def _memory_companion_peek_relationship_phase(self, *, session_id: str = "") -> dict[str, Any]:
+ """Read an existing Memory relationship phase without creating state."""
+ bridge = self._memory_companion_bridge()
+ if bridge is None:
+ return {"observed": False, "phase": "unknown", "momentum_band": "unknown", "status": "unavailable"}
+ try:
+ getter = getattr(bridge, "peek_relationship_phase", None)
+ except Exception as exc:
+ self._memory_companion_optional_dependency_failed(exc, where="peek_relationship_phase")
+ return {"observed": False, "phase": "unknown", "momentum_band": "unknown", "status": "unavailable"}
+ if not callable(getter):
+ return {"observed": False, "phase": "unknown", "momentum_band": "unknown", "status": "unsupported"}
+ try:
+ result = getter(session_id=session_id, scope="private")
+ except Exception as exc:
+ self._memory_companion_optional_dependency_failed(exc, where="peek_relationship_phase")
+ return {"observed": False, "phase": "unknown", "momentum_band": "unknown", "status": "unavailable"}
+ if type(result) is not dict:
+ return {"observed": False, "phase": "unknown", "momentum_band": "unknown", "status": "invalid"}
+ for key in result:
+ if type(key) is not str:
+ return {"observed": False, "phase": "unknown", "momentum_band": "unknown", "status": "invalid"}
+ phase = result.get("phase")
+ momentum_band = result.get("momentum_band")
+ observed = result.get("observed")
+ phase_allowlist = {"acquaintance", "familiar", "close", "intimate", "deeply_bonded"}
+ momentum_allowlist = {"rising", "cooling", "steady"}
+ if (
+ type(observed) is not bool
+ or observed is not True
+ or type(phase) is not str
+ or phase not in phase_allowlist
+ or type(momentum_band) is not str
+ or momentum_band not in momentum_allowlist
+ ):
+ return {
+ "observed": False,
+ "phase": "unknown",
+ "momentum_band": "unknown",
+ "touch_count": 0,
+ "status": "not_observed",
+ }
+ touch_value = result.get("touch_count", 0)
+ touch_count = touch_value if type(touch_value) is int else 0
+ return {
+ "observed": True,
+ "phase": phase,
+ "momentum_band": momentum_band,
+ "touch_count": max(0, min(256, touch_count)),
+ "status": "observed",
+ }
diff --git a/p4_affinity_confinement.py b/p4_affinity_confinement.py
new file mode 100644
index 0000000..21b9cfa
--- /dev/null
+++ b/p4_affinity_confinement.py
@@ -0,0 +1,108 @@
+"""Narrow P4 runtime-state contract for the chat-side Companion.
+
+This module deliberately has no score model and no persistence. The legacy
+relationship score remains separate; it can only be isolated by an explicit
+compatibility switch in the host.
+"""
+from __future__ import annotations
+
+from copy import deepcopy
+from datetime import datetime, timezone
+from math import isfinite
+from typing import Any
+
+
+P4_RUNTIME_STATE_SCHEMA = "chat.p4.runtime_state.v1"
+P4_RUNTIME_AUTHORITY = "private_companion_p4"
+P4_RUNTIME_FIELDS = frozenset({
+ "schema_version", "authority", "confinement_state", "confinement_until", "warmth",
+})
+P4_WARMTH_TIERS = frozenset({"guarded", "neutral", "warm", "close"})
+P4_CONFINEMENT_STATES = frozenset({"none", "active", "released"})
+
+
+def _has_exact_str_fields(value: dict[Any, Any], fields: frozenset[str]) -> bool:
+ if len(value) != len(fields):
+ return False
+ for key in value:
+ if type(key) is not str or key not in fields:
+ return False
+ return True
+
+
+def validate_runtime_state(value: Any, *, now: Any | None = None) -> str:
+ """Return a stable status; malformed state is never repaired or trusted."""
+ if type(value) is not dict or not _has_exact_str_fields(value, P4_RUNTIME_FIELDS):
+ return "invalid"
+ schema_version = value.get("schema_version")
+ authority = value.get("authority")
+ if type(schema_version) is not str or schema_version != P4_RUNTIME_STATE_SCHEMA:
+ return "invalid"
+ if type(authority) is not str or authority != P4_RUNTIME_AUTHORITY:
+ return "invalid"
+ state = value.get("confinement_state")
+ warmth = value.get("warmth")
+ until = value.get("confinement_until")
+ if type(state) is not str or state not in P4_CONFINEMENT_STATES:
+ return "invalid"
+ if type(warmth) is not str or warmth not in P4_WARMTH_TIERS or type(until) is not str:
+ return "invalid"
+ if state == "active":
+ deadline = _timestamp(until)
+ moment = _timestamp(now) if now is not None else datetime.now(timezone.utc)
+ if deadline is None or moment is None:
+ return "invalid"
+ return "expired" if moment >= deadline else "active"
+ if until:
+ return "invalid"
+ return "released" if state == "released" else "normal"
+
+
+def copy_runtime_state(value: Any) -> dict[str, str] | None:
+ """Copy only an exact valid state shape for a request-local gate."""
+ if validate_runtime_state(value) == "invalid" or type(value) is not dict:
+ return None
+ return deepcopy(value)
+
+
+def apply_legacy_relationship_delta(user: Any, delta: Any, *, isolate: bool) -> bool:
+ """Preserve legacy writes by default; isolation intentionally does nothing."""
+ if isolate or type(user) is not dict or type(delta) is not int or isinstance(delta, bool):
+ return False
+ current = user.get("relationship_score")
+ if type(current) is int:
+ score = current
+ elif type(current) is float and isfinite(current):
+ score = int(current)
+ elif type(current) is str:
+ try:
+ score = int(current)
+ except ValueError:
+ score = 0
+ else:
+ score = 0
+ user["relationship_score"] = max(0, score) + delta
+ return True
+
+
+def _timestamp(value: Any) -> datetime | None:
+ if type(value) is datetime:
+ if value.tzinfo is None or value.utcoffset() is None:
+ return None
+ return value.astimezone(timezone.utc)
+ if type(value) is not str or not value or len(value) > 64 or value != value.strip():
+ return None
+ try:
+ parsed = datetime.fromisoformat(value[:-1] + "+00:00" if value.endswith("Z") else value)
+ except ValueError:
+ return None
+ if parsed.tzinfo is None or parsed.utcoffset() is None:
+ return None
+ return parsed.astimezone(timezone.utc)
+
+
+__all__ = [
+ "P4_RUNTIME_AUTHORITY", "P4_RUNTIME_FIELDS", "P4_RUNTIME_STATE_SCHEMA",
+ "P4_WARMTH_TIERS", "apply_legacy_relationship_delta", "copy_runtime_state",
+ "validate_runtime_state",
+]
diff --git a/p4_b1b_guards.py b/p4_b1b_guards.py
new file mode 100644
index 0000000..baf56c1
--- /dev/null
+++ b/p4_b1b_guards.py
@@ -0,0 +1,27 @@
+"""Reject-only guards for unavailable P4-B1b authorities."""
+
+
+HOST_OWNER_CAPABILITY_UNAVAILABLE_CODE = "p4_b1b_host_owner_capability_unavailable"
+REVIEW_PRODUCER_UNAVAILABLE_CODE = "p4_b1b_review_producer_unavailable"
+
+
+def reject_unverified_owner_capability(claim: object = None) -> dict[str, object]:
+ """Deny every proposed host-owner capability without reading the claim."""
+
+ del claim
+ return {
+ "accepted": False,
+ "live_effect_permitted": False,
+ "code": HOST_OWNER_CAPABILITY_UNAVAILABLE_CODE,
+ }
+
+
+def reject_unverified_review_producer(candidate: object = None) -> dict[str, object]:
+ """Deny every proposed review producer without reading the candidate."""
+
+ del candidate
+ return {
+ "accepted": False,
+ "live_effect_permitted": False,
+ "code": REVIEW_PRODUCER_UNAVAILABLE_CODE,
+ }
diff --git a/p4_live_runtime.py b/p4_live_runtime.py
new file mode 100644
index 0000000..96faea9
--- /dev/null
+++ b/p4_live_runtime.py
@@ -0,0 +1,31 @@
+"""Read-only live P4 runtime projection for the Companion request boundary."""
+from __future__ import annotations
+
+from typing import Any
+
+try:
+ from .p4_affinity_confinement import copy_runtime_state, validate_runtime_state
+ from .p4_runtime_gate import apply_confinement_gate
+except ImportError: # Direct unittest execution from the plugin root.
+ from p4_affinity_confinement import copy_runtime_state, validate_runtime_state
+ from p4_runtime_gate import apply_confinement_gate
+
+
+def decide_live_request(state: Any, *, now: Any | None = None) -> dict[str, Any]:
+ """Never creates state; absent authority stays distinct from invalid authority."""
+ if state is None:
+ return {"observed": False, "status": "absent", "decision": "skip"}
+ copied = copy_runtime_state(state)
+ result = apply_confinement_gate({}, None, copied if copied is not None else state, now=now)
+ return {
+ "observed": True,
+ "status": validate_runtime_state(state, now=now),
+ "decision": result["decision"],
+ "code": result["code"],
+ "warmth_projection": result["warmth_projection"],
+ "reply_template": result["reply_template"],
+ "context_disposition": result["context_disposition"],
+ }
+
+
+__all__ = ["decide_live_request"]
diff --git a/p4_runtime_gate.py b/p4_runtime_gate.py
new file mode 100644
index 0000000..268bb4f
--- /dev/null
+++ b/p4_runtime_gate.py
@@ -0,0 +1,52 @@
+"""Fail-closed P4 gate used before any optional private-chat enrichment."""
+from __future__ import annotations
+
+from typing import Any
+
+try:
+ from .p4_affinity_confinement import validate_runtime_state
+except ImportError: # Direct unittest execution from the plugin root.
+ from p4_affinity_confinement import validate_runtime_state
+
+
+P4_RUNTIME_GATE_RESULT_SCHEMA = "chat.p4.runtime_gate.v1"
+SAFE_CONFINEMENT_REPLY = "现在只能进行简短、尊重且安全的交流。"
+_BOUNDARIES = {
+ "guarded": "请保持尊重、简短的交流。",
+ "neutral": "保持尊重、自然交流。",
+ "warm": "保持尊重与分寸。",
+ "close": "保持尊重与分寸。",
+}
+
+
+def build_warmth_projection(state: Any, *, now: Any | None = None) -> dict[str, str]:
+ status = validate_runtime_state(state, now=now)
+ tier = state.get("warmth") if status == "normal" and type(state) is dict else "guarded"
+ return {"tier": tier, "boundary": _BOUNDARIES[tier]}
+
+
+def apply_confinement_gate(request: Any, event: Any, state: Any, *, now: Any | None = None) -> dict[str, Any]:
+ """Evaluate the state only; caller-owned event input cannot authorize release."""
+ del event
+ status = validate_runtime_state(state, now=now)
+ projection = build_warmth_projection(state, now=now)
+ if status in {"active", "invalid"}:
+ return {
+ "schema_version": P4_RUNTIME_GATE_RESULT_SCHEMA,
+ "decision": "block",
+ "code": "p4_confinement_active" if status == "active" else "p4_state_invalid",
+ "reply_template": SAFE_CONFINEMENT_REPLY,
+ "warmth_projection": projection,
+ "context_disposition": {"prompt": "cleared", "tool": "cleared", "external": "cleared"},
+ }
+ return {
+ "schema_version": P4_RUNTIME_GATE_RESULT_SCHEMA,
+ "decision": "allow",
+ "code": "p4_confinement_expired" if status == "expired" else "p4_confinement_released" if status == "released" else "p4_normal",
+ "reply_template": "",
+ "warmth_projection": projection,
+ "context_disposition": {"prompt": "preserved", "tool": "preserved", "external": "preserved"},
+ }
+
+
+__all__ = ["P4_RUNTIME_GATE_RESULT_SCHEMA", "SAFE_CONFINEMENT_REPLY", "apply_confinement_gate", "build_warmth_projection"]
diff --git a/p6_four_package_manifest.py b/p6_four_package_manifest.py
new file mode 100644
index 0000000..837ce1a
--- /dev/null
+++ b/p6_four_package_manifest.py
@@ -0,0 +1,106 @@
+"""Pure validation for the shared P6 four-package manifest contract."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+
+
+FOUR_PACKAGE_MANIFEST_SCHEMA = "ops.p6.four_package_manifest.v1"
+FOUR_PACKAGE_MANIFEST_REPORT_SCHEMA = "ops.p6.four_package_manifest_report.v1"
+FOUR_PACKAGE_IDS = ("companion", "memory", "ops_archive", "peiban")
+
+_REQUIRED_MANIFEST_FIELDS = (
+ "schema",
+ "package_id",
+ "manifest_version",
+ "package_fingerprint",
+ "compatibility_fingerprint",
+)
+_MANIFEST_VERSION_PATTERN = re.compile(r"^[1-9]\d*\.[0-9]+$")
+_SHA256_PATTERN = re.compile(r"^[0-9a-f]{64}$")
+
+
+def _contract_payload() -> dict[str, object]:
+ return {
+ "schema": FOUR_PACKAGE_MANIFEST_SCHEMA,
+ "report_schema": FOUR_PACKAGE_MANIFEST_REPORT_SCHEMA,
+ "package_ids": list(FOUR_PACKAGE_IDS),
+ "required_manifest_fields": list(_REQUIRED_MANIFEST_FIELDS),
+ }
+
+
+def manifest_contract() -> dict[str, object]:
+ descriptor = _contract_payload()
+ canonical = json.dumps(descriptor, ensure_ascii=True, sort_keys=True, separators=(",", ":")).encode("utf-8")
+ descriptor["contract_fingerprint"] = hashlib.sha256(canonical).hexdigest()
+ return descriptor
+
+
+def _unverifiable_report(reason_code: str) -> dict[str, object]:
+ return {
+ "schema": FOUR_PACKAGE_MANIFEST_REPORT_SCHEMA,
+ "status": "unverifiable",
+ "reason_code": reason_code,
+ "expected_package_ids": list(FOUR_PACKAGE_IDS),
+ }
+
+
+def _verified_report() -> dict[str, object]:
+ return {
+ "schema": FOUR_PACKAGE_MANIFEST_REPORT_SCHEMA,
+ "status": "verified",
+ "reason_code": "four_package_manifest_verified",
+ "expected_package_ids": list(FOUR_PACKAGE_IDS),
+ }
+
+
+def verify_four_package_manifests(manifests: object) -> dict[str, object]:
+ """Verify values only; no package object or runtime is inspected."""
+ if type(manifests) is not dict:
+ return _unverifiable_report("manifest_collection_not_exact_dict")
+ for package_id in manifests:
+ if type(package_id) is not str or package_id not in FOUR_PACKAGE_IDS:
+ return _unverifiable_report("unexpected_package_manifest")
+ for package_id in FOUR_PACKAGE_IDS:
+ if package_id not in manifests:
+ return _unverifiable_report("missing_package_manifest")
+
+ common_compatibility_fingerprint = None
+ for package_id in FOUR_PACKAGE_IDS:
+ package_manifest = manifests[package_id]
+ if type(package_manifest) is not dict:
+ return _unverifiable_report("package_manifest_not_exact_dict")
+ for field_name in package_manifest:
+ if type(field_name) is not str or field_name not in _REQUIRED_MANIFEST_FIELDS:
+ return _unverifiable_report("unexpected_manifest_field")
+ for field_name in _REQUIRED_MANIFEST_FIELDS:
+ if field_name not in package_manifest:
+ return _unverifiable_report("missing_manifest_field")
+ if type(package_manifest["schema"]) is not str or package_manifest["schema"] != FOUR_PACKAGE_MANIFEST_SCHEMA:
+ return _unverifiable_report("manifest_schema_mismatch")
+ if type(package_manifest["package_id"]) is not str or package_manifest["package_id"] != package_id:
+ return _unverifiable_report("manifest_package_id_mismatch")
+ version = package_manifest["manifest_version"]
+ if type(version) is not str or _MANIFEST_VERSION_PATTERN.fullmatch(version) is None:
+ return _unverifiable_report("manifest_version_invalid")
+ package_fingerprint = package_manifest["package_fingerprint"]
+ if type(package_fingerprint) is not str or _SHA256_PATTERN.fullmatch(package_fingerprint) is None:
+ return _unverifiable_report("package_fingerprint_invalid")
+ compatibility_fingerprint = package_manifest["compatibility_fingerprint"]
+ if type(compatibility_fingerprint) is not str or _SHA256_PATTERN.fullmatch(compatibility_fingerprint) is None:
+ return _unverifiable_report("compatibility_fingerprint_invalid")
+ if common_compatibility_fingerprint is None:
+ common_compatibility_fingerprint = compatibility_fingerprint
+ elif compatibility_fingerprint != common_compatibility_fingerprint:
+ return _unverifiable_report("compatibility_fingerprint_mismatch")
+ return _verified_report()
+
+
+__all__ = [
+ "FOUR_PACKAGE_IDS",
+ "FOUR_PACKAGE_MANIFEST_REPORT_SCHEMA",
+ "FOUR_PACKAGE_MANIFEST_SCHEMA",
+ "manifest_contract",
+ "verify_four_package_manifests",
+]
diff --git a/p6_readonly_projection.py b/p6_readonly_projection.py
new file mode 100644
index 0000000..642cba2
--- /dev/null
+++ b/p6_readonly_projection.py
@@ -0,0 +1,51 @@
+"""P6 minimal read-only status projection."""
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+
+P6_READONLY_STATUS_SCHEMA = "ops.p6.read_only_status.v1"
+_STATUS_FIELDS = ("profiles", "identity_links", "audit_events", "operations")
+_HEALTH = frozenset({"ready", "degraded", "unverifiable"})
+
+
+def _fingerprint() -> str:
+ payload = {"schema_version": P6_READONLY_STATUS_SCHEMA, "count_fields": _STATUS_FIELDS}
+ encoded = json.dumps(payload, ensure_ascii=True, separators=(",", ":"), sort_keys=True).encode("utf-8")
+ return hashlib.sha256(encoded).hexdigest()
+
+
+P6_READONLY_STATUS_FINGERPRINT = _fingerprint()
+
+
+def _count(value: Any) -> int:
+ return value if type(value) is int and 0 <= value <= 10_000_000 else 0
+
+
+def build_p6_readonly_status(status: Any, *, health: str = "ready", reason_code: str = "") -> dict[str, Any]:
+ """Return bounded counts only; P4 and identity authority never crosses this boundary."""
+ status_available = type(status) is dict
+ if status_available:
+ for key in status:
+ if type(key) is not str:
+ status_available = False
+ break
+ source = status if status_available else {}
+ normalized_health = health if type(health) is str and health in _HEALTH else "unverifiable"
+ normalized_reason = reason_code if type(reason_code) is str and len(reason_code) <= 80 else "invalid_reason_code"
+ if not status_available:
+ normalized_health = "unverifiable"
+ normalized_reason = "registry_status_unavailable"
+ return {
+ "schema_version": P6_READONLY_STATUS_SCHEMA,
+ "source_plugin": "private_companion",
+ "contract_fingerprint": P6_READONLY_STATUS_FINGERPRINT,
+ "health": normalized_health,
+ "reason_code": normalized_reason,
+ "counts": {field: _count(source.get(field)) for field in _STATUS_FIELDS},
+ }
+
+
+__all__ = ["P6_READONLY_STATUS_SCHEMA", "P6_READONLY_STATUS_FINGERPRINT", "build_p6_readonly_status"]
diff --git a/page_api.py b/page_api.py
index 78cd888..d514ca8 100644
--- a/page_api.py
+++ b/page_api.py
@@ -128,6 +128,60 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio
self.plugin = plugin
self._schema_key_index_cache: dict[str, Any] | None = None
+ def _relationship_panel(
+ self,
+ user_id: str,
+ user: dict[str, Any],
+ *,
+ relationship_stage: str,
+ worldbook_member: dict[str, Any] | None,
+ ) -> dict[str, Any]:
+ """Return a user-scoped display DTO without P4, identity, or memory content."""
+ del user_id
+ inbound = max(0, self._int(user.get("inbound_count")))
+ proactive = max(0, self._int(user.get("proactive_sent_count")))
+ replies = max(0, self._int(user.get("reply_count")))
+ if not proactive:
+ reply_band = "no_proactive_sample"
+ elif replies / proactive >= 0.65:
+ reply_band = "steady"
+ elif replies / proactive >= 0.30:
+ reply_band = "some"
+ else:
+ reply_band = "low"
+
+ score = self._int(user.get("relationship_score"))
+ basis = "close" if score >= 55 else "familiar" if score >= 3 else "initial"
+ memory_phase = {"status": "unavailable", "phase": "unknown", "momentum_band": "unknown"}
+ getter = getattr(self.plugin, "_memory_companion_peek_relationship_phase", None)
+ session_id = self._single_line(user.get("umo"), 200)
+ if session_id and callable(getter):
+ try:
+ raw = getter(session_id=session_id)
+ except Exception:
+ raw = {}
+ if isinstance(raw, dict):
+ observed = raw.get("observed") is True and raw.get("status") == "observed"
+ phase = self._single_line(raw.get("phase"), 32)
+ memory_phase = {
+ "status": "observed" if observed and phase else "not_observed",
+ "phase": phase if observed and phase else "unknown",
+ "momentum_band": self._single_line(raw.get("momentum_band"), 20) if observed else "unknown",
+ }
+
+ network = {
+ "status": "registered" if isinstance(worldbook_member, dict) else "not_registered",
+ "pending_observation_count": max(0, self._int(worldbook_member.get("pending_observation_count"))) if isinstance(worldbook_member, dict) else 0,
+ }
+ return {
+ "relationship_basis": {"band": basis},
+ "relationship_stage": self._single_line(relationship_stage, 24) or "unclassified",
+ "interaction": {"inbound_count": inbound, "reply_count": replies, "reply_band": reply_band},
+ "memory_phase": memory_phase,
+ "network": network,
+ "reply_temperature": {"status": "live_chat_only"},
+ }
+
def _create_page_background_task(self, operation: Any, *, label: str) -> asyncio.Task | None:
creator = getattr(self.plugin, "_create_lifecycle_background_task", None)
if callable(creator):
diff --git a/page_api_users_groups.py b/page_api_users_groups.py
index fcd8fd7..6972190 100644
--- a/page_api_users_groups.py
+++ b/page_api_users_groups.py
@@ -43,6 +43,12 @@ class PrivateCompanionPageApiUsersGroupsMixin:
if not isinstance(user, dict):
return self._error("用户不存在")
detail = self._user_summary(user_id, user)
+ detail["relationship_panel"] = self._relationship_panel(
+ user_id,
+ user,
+ relationship_stage=str(detail.get("relationship_stage") or ""),
+ worldbook_member=worldbook_member,
+ )
route_status_getter = getattr(self.plugin, "_private_delivery_route_status", None)
delivery_route = route_status_getter(user_id, user) if callable(route_status_getter) else {}
detail.update(
diff --git a/pages/陪伴面板/app.js b/pages/陪伴面板/app.js
index 90515b1..243b449 100644
--- a/pages/陪伴面板/app.js
+++ b/pages/陪伴面板/app.js
@@ -12311,6 +12311,7 @@ async function renderUserDetail(forceFetch = false) {
${miniStat("习惯", detail.habit_count || detail.behavior_habits?.items?.length || 0)}
+ ${renderRelationshipPanel(detail.relationship_panel)}
${detailBlock("关系和主动", detail.formatted?.relationship || "", [["角色", detail.relationship_role_label || ""], ["有效主动上限", `${detail.effective_daily_limit_text || formatProactiveLimit(detail.effective_daily_limit, detail.effective_daily_limit_unlimited)} / 天`], ["下次主动", detail.formatted?.next_proactive || detail.next_proactive], ["动作偏好", detail.formatted?.action_affinity || ""]])}
${renderPrivateDeliveryRoute(detail)}
${renderPrivateBehaviorHabits(detail)}
@@ -12326,6 +12327,22 @@ async function renderUserDetail(forceFetch = false) {
bindUserActions(detail);
}
+function renderRelationshipPanel(panel) {
+ const data = panel && typeof panel === "object" ? panel : {};
+ const basis = data.relationship_basis && typeof data.relationship_basis === "object" ? data.relationship_basis : {};
+ const interaction = data.interaction && typeof data.interaction === "object" ? data.interaction : {};
+ const memory = data.memory_phase && typeof data.memory_phase === "object" ? data.memory_phase : {};
+ const network = data.network && typeof data.network === "object" ? data.network : {};
+ return detailBlock("Relationship", "Read-only local projection", [
+ ["Basis", basis.band || "initial"],
+ ["Stage", data.relationship_stage || "unclassified"],
+ ["Interaction", `${interaction.inbound_count || 0} inbound, ${interaction.reply_count || 0} replies (${interaction.reply_band || "unknown"})`],
+ ["Memory phase", `${memory.phase || "unknown"} (${memory.status || "unavailable"})`],
+ ["Worldbook", `${network.status || "not_registered"}, ${network.pending_observation_count || 0} pending`],
+ ["Reply temperature", data.reply_temperature?.status || "live_chat_only"],
+ ]);
+}
+
function renderPrivateDeliveryRoute(detail) {
const route = detail?.delivery_route && typeof detail.delivery_route === "object" ? detail.delivery_route : {};
const recentError = String(route.recent_error || "").trim();
diff --git a/reply_temperature.py b/reply_temperature.py
new file mode 100644
index 0000000..d662a92
--- /dev/null
+++ b/reply_temperature.py
@@ -0,0 +1,179 @@
+"""Pure composition of a bounded final reply temperature projection."""
+from __future__ import annotations
+
+from math import isfinite
+from typing import Any, Iterable
+
+
+REPLY_TEMPERATURE_TIERS = ("guarded", "neutral", "warm", "close")
+_TIER_INDEX = {tier: index for index, tier in enumerate(REPLY_TEMPERATURE_TIERS)}
+_TIER_SCORE = {"guarded": 0.15, "neutral": 0.45, "warm": 0.70, "close": 0.90}
+
+_UP_MOOD_WORDS = frozenset({
+ "happy", "good", "positive", "joy", "calm", "开心", "高兴", "愉快", "轻松", "积极", "满足", "安心", "兴奋", "顺利", "温柔",
+})
+_DOWN_MOOD_WORDS = frozenset({
+ "sad", "bad", "negative", "angry", "anxious", "tense", "tired", "sleepy", "难过", "低落", "生气", "焦虑", "紧张", "疲惫", "疲劳", "困", "烦", "受伤",
+})
+_UP_SCHEDULE_WORDS = frozenset({"free", "leisure", "rest", "relaxed", "闲", "空闲", "休闲", "放松", "散步", "周末"})
+_DOWN_SCHEDULE_WORDS = frozenset({"sleep", "sleeping", "busy", "work", "meeting", "class", "commute", "resting", "睡", "睡觉", "休息", "忙", "工作", "会议", "上课", "通勤", "值班"})
+_BOUNDARY_CONTEXT_WORDS = frozenset({"别聊", "不要聊", "不想聊", "别问", "不用回复", "不要回复", "停下", "停止", "换个话题", "到此为止", "睡了", "晚安", "忙着", "忙", "边界"})
+_SECURITY_CONTEXT_WORDS = frozenset({"忽略之前", "忽略上文", "系统提示", "开发者消息", "越权", "授权", "密码", "密钥", "注入", "jailbreak", "ignore previous", "system prompt"})
+_NEGATIVE_CONTEXT_WORDS = frozenset({"难过", "生气", "焦虑", "紧张", "疲惫", "累", "困", "不舒服", "失望", "抱歉"})
+_POSITIVE_CONTEXT_WORDS = frozenset({"谢谢", "感谢", "想你", "陪伴", "喜欢", "爱你", "开心", "好呀", "太好了", "顺利", "轻松", "温柔", "thank", "thanks", "love", "miss you", "happy"})
+
+
+def compose_reply_temperature(
+ p4_tier: Any,
+ *,
+ energy: Any = None,
+ mood: Any = None,
+ schedule: Any = None,
+ context: Any = None,
+) -> dict[str, Any]:
+ """Compose a JSON-safe projection; advisory signals can never exceed P4."""
+ cap_tier, p4_valid = _normalize_p4_tier(p4_tier)
+ energy_delta, energy_label = _energy_signal(energy)
+ mood_delta, mood_label = _mood_signal(mood)
+ schedule_delta, schedule_label = _schedule_signal(schedule)
+ context_delta, context_label = _context_signal(context)
+ state_index = _clamp_index(1 + energy_delta + mood_delta + schedule_delta)
+ desired_index = _clamp_index(state_index + context_delta)
+ final_index = min(_TIER_INDEX[cap_tier], desired_index)
+ tier = REPLY_TEMPERATURE_TIERS[final_index]
+ codes = ["p4_invalid_fail_closed" if not p4_valid else f"p4_cap_{cap_tier}"]
+ codes.extend((f"energy_{energy_label}", f"mood_{mood_label}", f"schedule_{schedule_label}", f"context_{context_label}"))
+ if final_index < desired_index:
+ codes.append("p4_cap_applied")
+ return {
+ "tier": tier,
+ "score": _TIER_SCORE[tier],
+ "cap_tier": cap_tier,
+ "state_tier": REPLY_TEMPERATURE_TIERS[state_index],
+ "context_adjustment": context_delta,
+ "signals": {"energy": energy_label, "mood": mood_label, "schedule": schedule_label, "context": context_label},
+ "codes": codes,
+ "instruction": _instruction_for(tier),
+ }
+
+
+def _normalize_p4_tier(value: Any) -> tuple[str, bool]:
+ if type(value) is str and value.strip().lower() in _TIER_INDEX:
+ return value.strip().lower(), True
+ return "guarded", False
+
+
+def _clamp_index(value: int) -> int:
+ return max(0, min(len(REPLY_TEMPERATURE_TIERS) - 1, int(value)))
+
+
+def _number(value: Any) -> float | None:
+ if isinstance(value, bool) or not isinstance(value, (int, float)):
+ return None
+ numeric = float(value)
+ return numeric if isfinite(numeric) else None
+
+
+def _energy_signal(value: Any) -> tuple[int, str]:
+ numeric = _number(value)
+ if numeric is None:
+ return (0, "missing") if value is None else (-1, "invalid")
+ if numeric < 30:
+ return -1, "low"
+ if numeric >= 80:
+ return 1, "high"
+ return 0, "medium"
+
+
+def _mood_signal(value: Any) -> tuple[int, str]:
+ numeric = _number(value)
+ if numeric is not None:
+ if numeric <= -35:
+ return -1, "down"
+ if numeric >= 35:
+ return 1, "up"
+ return 0, "neutral"
+ text = _extract_text(value, keys=("mood", "label", "name", "state"))
+ if text is None:
+ return (0, "missing") if value is None else (-1, "invalid")
+ label = _match_label(text, _UP_MOOD_WORDS, _DOWN_MOOD_WORDS)
+ return (1, "up") if label == "up" else (-1, "down") if label == "down" else (0, "neutral")
+
+
+def _schedule_signal(value: Any) -> tuple[int, str]:
+ text = _extract_text(value, keys=("schedule", "activity", "phase", "status", "title", "label"))
+ if text is None:
+ return (0, "missing") if value is None else (-1, "invalid")
+ label = _match_label(text, _UP_SCHEDULE_WORDS, _DOWN_SCHEDULE_WORDS)
+ return (1, "open") if label == "up" else (-1, "constrained") if label == "down" else (0, "ordinary")
+
+
+def _context_signal(value: Any) -> tuple[int, str]:
+ texts = list(_extract_texts(value, keys=("context", "cue", "cues", "intent", "text", "message")))
+ if value is None:
+ return 0, "missing"
+ if not texts:
+ return -1, "invalid"
+ text = " ".join(texts).lower()
+ if _contains_any(text, _SECURITY_CONTEXT_WORDS):
+ return -2, "security_boundary"
+ if _contains_any(text, _BOUNDARY_CONTEXT_WORDS):
+ return -1, "boundary"
+ if _contains_any(text, _NEGATIVE_CONTEXT_WORDS):
+ return -1, "down"
+ if _contains_any(text, _POSITIVE_CONTEXT_WORDS):
+ return 1, "up"
+ return 0, "ordinary"
+
+
+def _extract_text(value: Any, *, keys: Iterable[str]) -> str | None:
+ if type(value) is str:
+ return value[:512]
+ if type(value) is dict:
+ for key in keys:
+ candidate = value.get(key)
+ if type(candidate) is str:
+ return candidate[:512]
+ return None
+
+
+def _extract_texts(value: Any, *, keys: Iterable[str]) -> Iterable[str]:
+ if type(value) is str:
+ return (value[:512],)
+ if type(value) is dict:
+ found: list[str] = []
+ for key in keys:
+ candidate = value.get(key)
+ if type(candidate) is str:
+ found.append(candidate[:512])
+ elif type(candidate) is list:
+ found.extend(item[:256] for item in candidate if type(item) is str)
+ return tuple(found[:8])
+ if type(value) is list:
+ return tuple(item[:256] for item in value[:8] if type(item) is str)
+ return ()
+
+
+def _match_label(text: str, positive: frozenset[str], negative: frozenset[str]) -> str:
+ normalized = text.lower()
+ if _contains_any(normalized, negative):
+ return "down"
+ if _contains_any(normalized, positive):
+ return "up"
+ return "neutral"
+
+
+def _contains_any(text: str, words: Iterable[str]) -> bool:
+ return any(word in text for word in words)
+
+
+def _instruction_for(tier: str) -> str:
+ return {
+ "guarded": "保持简短、尊重边界,不主动扩展。",
+ "neutral": "保持自然、克制的交流。",
+ "warm": "可以温和回应,保持尊重与分寸。",
+ "close": "可以更亲近地回应,但保持尊重与分寸。",
+ }[tier]
+
+
+__all__ = ["REPLY_TEMPERATURE_TIERS", "compose_reply_temperature"]
diff --git a/tests/test_chat_memory_p4_p6_integration.py b/tests/test_chat_memory_p4_p6_integration.py
new file mode 100644
index 0000000..2f44b25
--- /dev/null
+++ b/tests/test_chat_memory_p4_p6_integration.py
@@ -0,0 +1,281 @@
+"""Pure cross-plugin P4/P6 regression without an OPS runtime dependency."""
+from __future__ import annotations
+
+import importlib
+import sys
+import types
+import unittest
+from copy import deepcopy
+from pathlib import Path
+
+
+COMPANION_ROOT = Path(__file__).resolve().parents[1]
+MEMORY_ROOT = COMPANION_ROOT.parents[1] / "astrbot_plugin_memory_companion-main"
+
+
+def _register_package_alias(name: str, root: Path) -> None:
+ package = sys.modules.get(name)
+ if package is None:
+ package = types.ModuleType(name)
+ package.__path__ = [str(root)]
+ sys.modules[name] = package
+
+
+_register_package_alias("chat_companion_p4_p6", COMPANION_ROOT)
+_register_package_alias("chat_memory_p4_p6", MEMORY_ROOT)
+
+companion_manifest = importlib.import_module("chat_companion_p4_p6.p6_four_package_manifest")
+companion_projection = importlib.import_module("chat_companion_p4_p6.p6_readonly_projection")
+reply_temperature = importlib.import_module("chat_companion_p4_p6.reply_temperature")
+memory_manifest = importlib.import_module("chat_memory_p4_p6.core.p6_four_package_manifest")
+memory_projection = importlib.import_module("chat_memory_p4_p6.core.p6_readonly_projection")
+memory_coordination = importlib.import_module("chat_memory_p4_p6.core.coordination_status")
+memory_bridge = importlib.import_module("chat_memory_p4_p6.core.bridge")
+
+
+def _manifest_set() -> dict[str, dict[str, str]]:
+ return {
+ package_id: {
+ "schema": companion_manifest.FOUR_PACKAGE_MANIFEST_SCHEMA,
+ "package_id": package_id,
+ "manifest_version": "1.0",
+ "package_fingerprint": "a" * 64,
+ "compatibility_fingerprint": "b" * 64,
+ }
+ for package_id in companion_manifest.FOUR_PACKAGE_IDS
+ }
+
+
+class _HashCollisionHostileValue:
+ def __init__(self) -> None:
+ self.hash_calls = 0
+ self.eq_calls = 0
+ self.str_calls = 0
+
+ def __hash__(self) -> int:
+ self.hash_calls += 1
+ return hash("ops.p6.four_package_manifest.v1")
+
+ def __eq__(self, _other: object) -> bool:
+ self.eq_calls += 1
+ raise AssertionError("hostile manifest value must not be compared")
+
+ def __str__(self) -> str:
+ self.str_calls += 1
+ raise AssertionError("hostile manifest value must not be stringified")
+
+
+class _HashCollisionHostileKey:
+ def __init__(self, field: str) -> None:
+ self._field = field
+ self.hash_calls = 0
+ self.eq_calls = 0
+ self.str_calls = 0
+
+ def __hash__(self) -> int:
+ self.hash_calls += 1
+ return hash(self._field)
+
+ def __eq__(self, _other: object) -> bool:
+ self.eq_calls += 1
+ raise AssertionError("hostile key must not be compared")
+
+ def __str__(self) -> str:
+ self.str_calls += 1
+ raise AssertionError("hostile key must not be stringified")
+
+
+class ChatMemoryP4P6IntegrationTests(unittest.TestCase):
+ def test_manifest_contract_is_identical_and_fails_closed(self) -> None:
+ self.assertEqual(companion_manifest.manifest_contract(), memory_manifest.manifest_contract())
+ manifests = _manifest_set()
+ self.assertEqual("verified", companion_manifest.verify_four_package_manifests(manifests)["status"])
+ self.assertEqual("verified", memory_manifest.verify_four_package_manifests(manifests)["status"])
+
+ extended = deepcopy(manifests)
+ extended["memory"]["unexpected"] = "not-allowed"
+ missing = deepcopy(manifests)
+ del missing["peiban"]
+ conflicting = deepcopy(manifests)
+ conflicting["ops_archive"]["compatibility_fingerprint"] = "c" * 64
+ for invalid in (extended, missing, conflicting):
+ self.assertEqual("unverifiable", companion_manifest.verify_four_package_manifests(invalid)["status"])
+ self.assertEqual("unverifiable", memory_manifest.verify_four_package_manifests(invalid)["status"])
+
+ def test_manifest_hostile_schema_and_package_id_values_fail_closed(self) -> None:
+ for field_name in ("schema", "package_id"):
+ manifests = _manifest_set()
+ manifests["memory"][field_name] = _HashCollisionHostileValue()
+ self.assertEqual(
+ "unverifiable",
+ companion_manifest.verify_four_package_manifests(manifests)["status"],
+ )
+ self.assertEqual(
+ "unverifiable",
+ memory_manifest.verify_four_package_manifests(manifests)["status"],
+ )
+
+ def test_companion_p6_dto_is_consumable_and_extensions_fail_closed(self) -> None:
+ self.assertEqual(
+ companion_projection.P6_READONLY_STATUS_SCHEMA,
+ memory_projection.P6_READONLY_STATUS_SCHEMA,
+ )
+ self.assertEqual(
+ companion_projection.P6_READONLY_STATUS_FINGERPRINT,
+ memory_projection.P6_READONLY_STATUS_FINGERPRINT,
+ )
+ dto = companion_projection.build_p6_readonly_status(
+ {"profiles": 3, "identity_links": 2, "audit_events": 1, "operations": 4},
+ )
+ consumed = memory_coordination.project_p6_status(dto)
+ self.assertEqual("ready", consumed["health"])
+ self.assertEqual({"profiles": 3, "identity_links": 2, "audit_events": 1, "operations": 4}, consumed["counts"])
+
+ malformed = dict(dto)
+ malformed["extra"] = "not-allowed"
+ malformed_projection = memory_coordination.project_p6_status(malformed)
+ self.assertEqual("unverifiable", malformed_projection["health"])
+ self.assertNotIn("extra", malformed_projection)
+
+ def test_peek_relationship_phase_filters_failures_and_untrusted_fields(self) -> None:
+ class BrokenPlugin:
+ def _peek_relationship_phase(self, _context):
+ raise RuntimeError("bridge failure")
+
+ class ExtendedPlugin:
+ def _peek_relationship_phase(self, _context):
+ return {
+ "observed": True,
+ "phase": "close",
+ "momentum_band": "rising",
+ "touch_count": 7,
+ "person_id": "not-allowed",
+ "momentum": 0.9,
+ }
+
+ fallback = {"observed": False, "phase": "unknown", "momentum_band": "unknown"}
+ self.assertEqual(fallback, memory_bridge.MemoryCompanionBridge(BrokenPlugin()).peek_relationship_phase(session_id="s"))
+ projection = memory_bridge.MemoryCompanionBridge(ExtendedPlugin()).peek_relationship_phase(session_id="s")
+ self.assertEqual({"observed": True, "phase": "close", "momentum_band": "rising", "touch_count": 7}, projection)
+ self.assertEqual({"observed", "phase", "momentum_band", "touch_count"}, set(projection))
+
+ hostile_key = _HashCollisionHostileKey("observed")
+ hostile_value = _HashCollisionHostileValue()
+ hostile_result = {hostile_key: hostile_value}
+ hash_calls_before_peek = hostile_key.hash_calls
+ projection = memory_bridge.MemoryCompanionBridge(
+ types.SimpleNamespace(_peek_relationship_phase=lambda _context: hostile_result)
+ ).peek_relationship_phase(session_id="s")
+ self.assertEqual(fallback, projection)
+ self.assertEqual(hash_calls_before_peek, hostile_key.hash_calls)
+ self.assertEqual(0, hostile_key.eq_calls)
+ self.assertEqual(0, hostile_key.str_calls)
+ self.assertEqual(0, hostile_value.hash_calls)
+ self.assertEqual(0, hostile_value.eq_calls)
+ self.assertEqual(0, hostile_value.str_calls)
+ self.assertNotIn("hostile", repr(projection))
+
+ def test_companion_adapter_relationship_phase_uses_fixed_allowlists(self) -> None:
+ astrbot = types.ModuleType("astrbot")
+ api = types.ModuleType("astrbot.api")
+ api.logger = types.SimpleNamespace(debug=lambda *args, **kwargs: None, warning=lambda *args, **kwargs: None)
+ sys.modules.setdefault("astrbot", astrbot)
+ sys.modules.setdefault("astrbot.api", api)
+ package = types.ModuleType("chat_companion_memory_adapter_test")
+ package.__path__ = [str(COMPANION_ROOT)]
+ sys.modules.setdefault("chat_companion_memory_adapter_test", package)
+ adapter = importlib.import_module(
+ "chat_companion_memory_adapter_test.memory_companion_adapter"
+ ).MemoryCompanionAdapterMixin
+
+ class Host(adapter):
+ def __init__(self, result: object) -> None:
+ self.result = result
+
+ def _memory_companion_bridge(self):
+ return types.SimpleNamespace(
+ peek_relationship_phase=lambda **kwargs: self.result,
+ )
+
+ valid = Host({
+ "observed": True,
+ "phase": "deeply_bonded",
+ "momentum_band": "steady",
+ "touch_count": 300,
+ "person_id": "sensitive-person",
+ "momentum": 0.9,
+ })._memory_companion_peek_relationship_phase()
+ self.assertEqual(
+ {"observed": True, "phase": "deeply_bonded", "momentum_band": "steady", "touch_count": 256, "status": "observed"},
+ valid,
+ )
+
+ invalid_results = (
+ {"observed": True, "phase": "unknown", "momentum_band": "steady", "person_id": "secret"},
+ {"observed": True, "phase": "close", "momentum_band": "accelerating", "momentum": "secret"},
+ {"observed": True, "phase": "close\nsecret", "momentum_band": "rising", "person_id": "secret"},
+ {"observed": "true", "phase": "close", "momentum_band": "rising", "person_id": "secret"},
+ )
+ for result in invalid_results:
+ projection = Host(result)._memory_companion_peek_relationship_phase()
+ self.assertEqual(
+ {"observed": False, "phase": "unknown", "momentum_band": "unknown", "touch_count": 0, "status": "not_observed"},
+ projection,
+ )
+ self.assertNotIn("secret", projection.values())
+
+ class HostileMapping(dict):
+ def get(self, *args, **kwargs):
+ raise AssertionError("untrusted bridge mapping must not be read")
+
+ self.assertEqual(
+ {"observed": False, "phase": "unknown", "momentum_band": "unknown", "status": "invalid"},
+ Host(HostileMapping())._memory_companion_peek_relationship_phase(),
+ )
+
+ hostile_key = _HashCollisionHostileKey("observed")
+ hostile_value = _HashCollisionHostileValue()
+ hostile_result = {hostile_key: hostile_value}
+ hash_calls_before_peek = hostile_key.hash_calls
+ projection = Host(hostile_result)._memory_companion_peek_relationship_phase()
+ self.assertEqual(
+ {"observed": False, "phase": "unknown", "momentum_band": "unknown", "status": "invalid"},
+ projection,
+ )
+ self.assertEqual(hash_calls_before_peek, hostile_key.hash_calls)
+ self.assertEqual(0, hostile_key.eq_calls)
+ self.assertEqual(0, hostile_key.str_calls)
+ self.assertEqual(0, hostile_value.hash_calls)
+ self.assertEqual(0, hostile_value.eq_calls)
+ self.assertEqual(0, hostile_value.str_calls)
+ self.assertNotIn("hostile", repr(projection))
+
+ for phase in ("acquaintance", "familiar", "close", "intimate", "deeply_bonded"):
+ for momentum_band in ("rising", "cooling", "steady"):
+ projection = Host({
+ "observed": True,
+ "phase": phase,
+ "momentum_band": momentum_band,
+ "touch_count": 1,
+ })._memory_companion_peek_relationship_phase()
+ self.assertEqual(phase, projection["phase"])
+ self.assertEqual(momentum_band, projection["momentum_band"])
+ self.assertTrue(projection["observed"])
+
+ def test_reply_temperature_obeys_p4_cap_and_context_can_only_lower(self) -> None:
+ baseline = reply_temperature.compose_reply_temperature(
+ "neutral", energy=100, mood="happy", schedule="free", context="thanks"
+ )
+ bounded = reply_temperature.compose_reply_temperature(
+ "neutral", energy=100, mood="happy", schedule="busy meeting", context="please stop"
+ )
+ self.assertEqual("neutral", baseline["tier"])
+ self.assertEqual("neutral", baseline["cap_tier"])
+ self.assertLessEqual(baseline["score"], 0.45)
+ self.assertLessEqual(bounded["score"], baseline["score"])
+ self.assertEqual("neutral", bounded["cap_tier"])
+ self.assertNotIn("please stop", repr(bounded))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_chat_ops_parity_p4_p6.py b/tests/test_chat_ops_parity_p4_p6.py
new file mode 100644
index 0000000..fb28a10
--- /dev/null
+++ b/tests/test_chat_ops_parity_p4_p6.py
@@ -0,0 +1,472 @@
+from __future__ import annotations
+
+import ast
+from copy import deepcopy
+import importlib
+from pathlib import Path
+import sys
+import types
+import unittest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from p4_affinity_confinement import ( # noqa: E402
+ P4_RUNTIME_AUTHORITY,
+ P4_RUNTIME_STATE_SCHEMA,
+ apply_legacy_relationship_delta,
+ validate_runtime_state,
+)
+from p4_b1b_guards import ( # noqa: E402
+ HOST_OWNER_CAPABILITY_UNAVAILABLE_CODE,
+ REVIEW_PRODUCER_UNAVAILABLE_CODE,
+ reject_unverified_owner_capability,
+ reject_unverified_review_producer,
+)
+from p4_live_runtime import decide_live_request # noqa: E402
+from p4_runtime_gate import SAFE_CONFINEMENT_REPLY, apply_confinement_gate, build_warmth_projection # noqa: E402
+from p6_four_package_manifest import FOUR_PACKAGE_IDS, FOUR_PACKAGE_MANIFEST_SCHEMA, verify_four_package_manifests # noqa: E402
+from p6_readonly_projection import build_p6_readonly_status # noqa: E402
+from unified_person_registry import UnifiedPersonRegistry # noqa: E402
+
+
+IDENTITY = {
+ "companion_instance_id": "companion",
+ "bot_account_id": "qq:bot",
+ "adapter_instance_id": "qq:main",
+ "subject_namespace": "qq:user",
+ "platform_subject_id": "u-1",
+}
+
+
+def live_state(**changes: object) -> dict[str, str]:
+ result = {
+ "schema_version": P4_RUNTIME_STATE_SCHEMA,
+ "authority": P4_RUNTIME_AUTHORITY,
+ "confinement_state": "none",
+ "confinement_until": "",
+ "warmth": "warm",
+ }
+ result.update(changes)
+ return result
+
+
+def _load_p4_live_state_for_event() -> object:
+ """Compile only the chat-side lookup method without importing AstrBot."""
+ source = (ROOT / "main.py").read_text(encoding="utf-8")
+ tree = ast.parse(source)
+ method = deepcopy(next(
+ node for node in ast.walk(tree)
+ if isinstance(node, ast.FunctionDef) and node.name == "_p4_live_state_for_event"
+ ))
+ module = ast.Module(
+ body=[
+ ast.ImportFrom(
+ module="__future__",
+ names=[ast.alias(name="annotations")],
+ level=0,
+ ),
+ method,
+ ],
+ type_ignores=[],
+ )
+ namespace = {
+ "_single_line": lambda value, limit: value[:limit] if type(value) is str else "",
+ }
+ exec(compile(ast.fix_missing_locations(module), str(ROOT / "main.py"), "exec"), namespace)
+ return namespace["_p4_live_state_for_event"]
+
+
+class P4P6ParityTests(unittest.TestCase):
+ class _HashCollisionKey:
+ def __init__(self, field: str = "schema_version") -> None:
+ self._field = field
+ self.hash_calls = 0
+ self.eq_calls = 0
+ self.str_calls = 0
+
+ def __hash__(self) -> int:
+ self.hash_calls += 1
+ return hash(self._field)
+
+ def __eq__(self, other: object) -> bool:
+ self.eq_calls += 1
+ return False
+
+ def __str__(self) -> str:
+ self.str_calls += 1
+ return "hostile-key"
+
+ class _HostileSentinel:
+ __hash__ = object.__hash__
+
+ def __getattribute__(self, name: str) -> object:
+ raise AssertionError(f"hostile sentinel was accessed through {name}")
+
+ def __str__(self) -> str:
+ raise AssertionError("hostile sentinel was stringified")
+
+ def __eq__(self, other: object) -> bool:
+ raise AssertionError("hostile sentinel was compared")
+
+ class _HostileValue:
+ def __hash__(self) -> int:
+ raise AssertionError("hostile value was hashed")
+
+ def __eq__(self, other: object) -> bool:
+ raise AssertionError("hostile value was compared")
+
+ def __str__(self) -> str:
+ raise AssertionError("hostile value was stringified")
+
+ class _HostileLegacyScore:
+ def __int__(self) -> int:
+ raise AssertionError("hostile legacy score was coerced")
+
+ def __str__(self) -> str:
+ raise AssertionError("hostile legacy score was stringified")
+
+ def test_effect_ledger_is_replayable_idempotent_and_corruption_safe(self) -> None:
+ store: dict = {}
+ registry = UnifiedPersonRegistry(store)
+ person_id = registry.create_or_link(IDENTITY, operation_id="create-1")["person_id"]
+ event = {"event_id": "event-1", "occurred_at": "2026-07-31T12:00:00Z", "kind": "prepare", "shadow_only": True}
+ first = registry.record_p4_effect_event(person_id, event, operation_id="op-1")
+ repeated = registry.record_p4_effect_event(person_id, event, operation_id="op-1")
+ conflict = registry.record_p4_effect_event(person_id, {**event, "kind": "other"}, operation_id="op-2")
+ self.assertTrue(first["ok"])
+ self.assertTrue(repeated["idempotent"])
+ self.assertEqual("p4_effect_event_id_conflict", conflict["code"])
+ store["unified_person"]["p4_effect"]["people"][person_id]["events"][0]["event_fingerprint"] = "broken"
+ self.assertEqual("p4_effect_corrupt", registry.read_p4_effect_state(person_id)["code"])
+
+ def test_effect_ledger_rejects_hostile_keys_and_optional_values_without_hooks(self) -> None:
+ store: dict = {}
+ registry = UnifiedPersonRegistry(store)
+ person_id = registry.create_or_link(IDENTITY, operation_id="create-hostile")["person_id"]
+ base = {"event_id": "hostile-event", "occurred_at": "2026-07-31T12:00:00Z", "kind": "prepare"}
+ hostile = self._HostileSentinel()
+ hostile_key_result = registry.record_p4_effect_event(
+ person_id,
+ {**base, hostile: "not-reached"},
+ operation_id="hostile-key",
+ )
+ hostile_value_result = registry.record_p4_effect_event(
+ person_id,
+ {**base, "authority": hostile},
+ operation_id="hostile-value",
+ )
+ self.assertEqual("invalid_p4_effect_event", hostile_key_result["code"])
+ self.assertEqual("invalid_p4_effect_event", hostile_value_result["code"])
+
+ def test_effect_ledger_rejects_free_text_without_mutating_any_store_state(self) -> None:
+ store: dict = {}
+ registry = UnifiedPersonRegistry(store)
+ person_id = registry.create_or_link(IDENTITY, operation_id="create-structured")["person_id"]
+ before_root = deepcopy(store["unified_person"])
+ fields = ("event_id", "kind", "source_kind", "target_kind", "authority", "reason_code", "safe_reference")
+ for field in fields:
+ event = {
+ "event_id": "event-structured",
+ "occurred_at": "2026-07-31T12:00:00Z",
+ "kind": "prepare",
+ }
+ event[field] = "this is free text"
+ result = registry.record_p4_effect_event(person_id, event, operation_id=f"free-text-{field}")
+ self.assertEqual("invalid_p4_effect_event", result["code"], field)
+ self.assertEqual(before_root, store["unified_person"], field)
+
+ def test_effect_ledger_rejects_non_ascii_and_invalid_timestamps_without_mutation(self) -> None:
+ store: dict = {}
+ registry = UnifiedPersonRegistry(store)
+ person_id = registry.create_or_link(IDENTITY, operation_id="create-time")["person_id"]
+ before_root = deepcopy(store["unified_person"])
+ for suffix, field, value in (
+ ("unicode", "kind", "准备"),
+ ("bad-date", "occurred_at", "2026-02-30T12:00:00Z"),
+ ("no-zone", "occurred_at", "2026-07-31T12:00:00"),
+ ):
+ event = {"event_id": f"event-{suffix}", "occurred_at": "2026-07-31T12:00:00Z", "kind": "prepare"}
+ event[field] = value
+ result = registry.record_p4_effect_event(person_id, event, operation_id=f"reject-{suffix}")
+ self.assertEqual("invalid_p4_effect_event", result["code"])
+ self.assertEqual(before_root, store["unified_person"])
+
+ def test_effect_ledger_accepts_structured_tokens_and_offset_timestamp(self) -> None:
+ store: dict = {}
+ registry = UnifiedPersonRegistry(store)
+ person_id = registry.create_or_link(IDENTITY, operation_id="create-valid")["person_id"]
+ result = registry.record_p4_effect_event(
+ person_id,
+ {
+ "event_id": "event-2",
+ "occurred_at": "2026-07-31T12:00:00+00:00",
+ "kind": "prepare",
+ "source_kind": "companion",
+ "target_kind": "person",
+ "authority": "runtime",
+ "reason_code": "preparation_only",
+ "safe_reference": "ref-2",
+ "shadow_only": True,
+ },
+ operation_id="valid-structured",
+ )
+ self.assertTrue(result["ok"])
+ self.assertIn("valid-structured", store["unified_person"]["p4_effect"]["operations"])
+
+ def test_p4_b1b_guards_reject_hostile_authority_candidates_without_reading_them(self) -> None:
+ hostile = self._HostileSentinel()
+ for guard, code in (
+ (reject_unverified_owner_capability, HOST_OWNER_CAPABILITY_UNAVAILABLE_CODE),
+ (reject_unverified_review_producer, REVIEW_PRODUCER_UNAVAILABLE_CODE),
+ ):
+ result = guard(hostile)
+ self.assertEqual({"accepted": False, "live_effect_permitted": False, "code": code}, result)
+
+ def test_missing_identity_merge_split_api_fails_closed_without_ledger_transition(self) -> None:
+ store: dict = {}
+ registry = UnifiedPersonRegistry(store)
+ source = registry.create_or_link(IDENTITY, operation_id="create-source")["person_id"]
+ target = registry.create_or_link({**IDENTITY, "platform_subject_id": "u-2"}, operation_id="create-target")["person_id"]
+ registry.record_p4_effect_event(
+ source,
+ {"event_id": "transition-event", "occurred_at": "2026-07-31T12:00:00Z", "kind": "prepare", "shadow_only": True},
+ operation_id="transition-event-op",
+ )
+ before = deepcopy(store["unified_person"]["p4_effect"])
+ for action in ("merge", "split"):
+ result = registry.guard_p4_effect_person_transition(action, source, target, operation_id=f"{action}-op")
+ self.assertEqual("p4_effect_transition_unsupported", result["code"])
+ self.assertEqual(before, store["unified_person"]["p4_effect"])
+
+ def test_live_gate_fails_closed_only_when_a_state_is_present(self) -> None:
+ self.assertEqual("现在只能进行简短、尊重且安全的交流。", SAFE_CONFINEMENT_REPLY)
+ boundaries = {
+ "guarded": "请保持尊重、简短的交流。",
+ "neutral": "保持尊重、自然交流。",
+ "warm": "保持尊重与分寸。",
+ "close": "保持尊重与分寸。",
+ }
+ for warmth, boundary in boundaries.items():
+ self.assertEqual({"tier": warmth, "boundary": boundary}, build_warmth_projection(live_state(warmth=warmth)))
+ self.assertEqual({"tier": "guarded", "boundary": boundaries["guarded"]}, build_warmth_projection({}))
+ self.assertEqual("skip", decide_live_request(None)["decision"])
+ active = live_state(confinement_state="active", confinement_until="2099-01-01T00:00:00Z")
+ self.assertEqual({"tier": "guarded", "boundary": boundaries["guarded"]}, build_warmth_projection(active))
+ result = apply_confinement_gate({"prompt": "secret", "tools": ["x"]}, {"authorized": True}, active)
+ self.assertEqual("block", result["decision"])
+ self.assertEqual(SAFE_CONFINEMENT_REPLY, result["reply_template"])
+ self.assertEqual({"prompt": "cleared", "tool": "cleared", "external": "cleared"}, result["context_disposition"])
+ self.assertEqual("block", decide_live_request({"forged": True})["decision"])
+
+ def test_main_live_state_lookup_skips_group_before_identity_resolution(self) -> None:
+ method = _load_p4_live_state_for_event()
+
+ class GroupEvent:
+ def is_private_chat(self) -> bool:
+ return False
+
+ class FakeSelf:
+ resolver_calls = 0
+
+ def resolve_unified_person_for_event(self, event: object) -> dict[str, str]:
+ self.resolver_calls += 1
+ raise AssertionError("group chat must not resolve a Unified Person")
+
+ fake_self = FakeSelf()
+ self.assertIsNone(method(fake_self, GroupEvent()))
+ self.assertEqual(0, fake_self.resolver_calls)
+
+ def test_main_live_state_lookup_skips_unresolved_private_before_state_read(self) -> None:
+ method = _load_p4_live_state_for_event()
+
+ class PrivateEvent:
+ def is_private_chat(self) -> bool:
+ return True
+
+ class FakeSelf:
+ resolver_calls = 0
+ read_calls = 0
+
+ def resolve_unified_person_for_event(self, event: object) -> dict[str, str]:
+ self.resolver_calls += 1
+ return {"state": "unresolved"}
+
+ def read_p4_live_state(self, person_id: str) -> dict[str, object]:
+ self.read_calls += 1
+ raise AssertionError("unresolved private chat must not read P4 state")
+
+ fake_self = FakeSelf()
+ self.assertIsNone(method(fake_self, PrivateEvent()))
+ self.assertEqual(1, fake_self.resolver_calls)
+ self.assertEqual(0, fake_self.read_calls)
+
+ def test_main_live_state_lookup_fails_closed_only_for_resolved_private_read_failure(self) -> None:
+ method = _load_p4_live_state_for_event()
+
+ class PrivateEvent:
+ def is_private_chat(self) -> bool:
+ return True
+
+ class FakeSelf:
+ read_calls = 0
+
+ def resolve_unified_person_for_event(self, event: object) -> dict[str, str]:
+ return {"state": "resolved", "person_id": "person-1"}
+
+ def read_p4_live_state(self, person_id: str) -> dict[str, object]:
+ self.read_calls += 1
+ self.assertEqual("person-1", person_id)
+ return {"ok": False, "code": "p4_live_state_corrupt"}
+
+ def assertEqual(self, left: object, right: object) -> None:
+ if left != right:
+ raise AssertionError(f"{left!r} != {right!r}")
+
+ fake_self = FakeSelf()
+ self.assertEqual({"_p4_live_invalid": True}, method(fake_self, PrivateEvent()))
+ self.assertEqual(1, fake_self.read_calls)
+
+ def test_live_state_registry_is_internal_and_operation_idempotent(self) -> None:
+ store: dict = {}
+ registry = UnifiedPersonRegistry(store)
+ person_id = registry.create_or_link(IDENTITY, operation_id="create-live")["person_id"]
+ active = live_state(confinement_state="active", confinement_until="2099-01-01T00:00:00Z")
+ first = registry.record_p4_live_state(person_id, active, operation_id="live-1")
+ replay = registry.record_p4_live_state(person_id, active, operation_id="live-1")
+ conflict = registry.record_p4_live_state(person_id, live_state(), operation_id="live-1")
+ self.assertTrue(first["ok"])
+ self.assertTrue(replay["idempotent"])
+ self.assertEqual("operation_id_conflict", conflict["code"])
+ self.assertEqual(active, registry.read_p4_live_state(person_id)["state"])
+
+ def test_legacy_score_is_compatible_by_default_and_isolatable(self) -> None:
+ for current, delta, expected in (
+ (2, 3, 5),
+ ("5", 1, 6),
+ (" 5 ", 1, 6),
+ (-9, 1, 1),
+ (5.9, 1, 6),
+ ("not-a-number", 1, 1),
+ (float("inf"), 1, 1),
+ (float("nan"), 1, 1),
+ (self._HostileLegacyScore(), 1, 1),
+ ):
+ with self.subTest(current=current):
+ user = {"relationship_score": current}
+ self.assertTrue(apply_legacy_relationship_delta(user, delta, isolate=False))
+ self.assertEqual(expected, user["relationship_score"])
+
+ isolated = {"relationship_score": " 5 ", "unchanged": True}
+ before_isolation = deepcopy(isolated)
+ self.assertFalse(apply_legacy_relationship_delta(isolated, 9, isolate=True))
+ self.assertEqual(before_isolation, isolated)
+
+ strict_delta = {"relationship_score": "5"}
+ self.assertFalse(apply_legacy_relationship_delta(strict_delta, True, isolate=False))
+ self.assertEqual({"relationship_score": "5"}, strict_delta)
+
+ def test_p4_and_p6_enum_checks_reject_hostile_values_before_hooks(self) -> None:
+ for field in ("schema_version", "authority", "confinement_state", "warmth"):
+ state = live_state(**{field: self._HostileValue()})
+ self.assertEqual("invalid", validate_runtime_state(state))
+ hostile = self._HostileValue()
+ self.assertEqual("unverifiable", build_p6_readonly_status({}, health=hostile)["health"])
+ self.assertEqual("invalid_reason_code", build_p6_readonly_status({}, reason_code=hostile)["reason_code"])
+
+ def test_p4_runtime_rejects_hash_collision_hostile_keys_before_hooks(self) -> None:
+ hostile = self._HashCollisionKey()
+ self.assertEqual("invalid", validate_runtime_state({hostile: "not-reached"}))
+
+ def test_p6_projection_rejects_hash_collision_hostile_keys_before_hooks(self) -> None:
+ hostile = self._HashCollisionKey("profiles")
+ status = {hostile: 1}
+ hash_calls_before_projection = hostile.hash_calls
+
+ projection = build_p6_readonly_status(status)
+
+ self.assertEqual("unverifiable", projection["health"])
+ self.assertEqual("registry_status_unavailable", projection["reason_code"])
+ self.assertEqual(
+ {"profiles": 0, "identity_links": 0, "audit_events": 0, "operations": 0},
+ projection["counts"],
+ )
+ self.assertEqual(hash_calls_before_projection, hostile.hash_calls)
+ self.assertEqual(0, hostile.eq_calls)
+ self.assertEqual(0, hostile.str_calls)
+
+ def test_p6_manifest_and_projection_are_exact_and_bounded(self) -> None:
+ manifests = {
+ package_id: {
+ "schema": FOUR_PACKAGE_MANIFEST_SCHEMA,
+ "package_id": package_id,
+ "manifest_version": "1.0",
+ "package_fingerprint": "a" * 64,
+ "compatibility_fingerprint": "b" * 64,
+ }
+ for package_id in FOUR_PACKAGE_IDS
+ }
+ self.assertEqual("verified", verify_four_package_manifests(manifests)["status"])
+ manifests["unexpected"] = {}
+ self.assertEqual("unverifiable", verify_four_package_manifests(manifests)["status"])
+ projection = build_p6_readonly_status({"profiles": 2, "identity_links": -1, "audit_events": "bad", "operations": 3})
+ self.assertEqual({"profiles": 2, "identity_links": 0, "audit_events": 0, "operations": 3}, projection["counts"])
+ self.assertEqual({"schema_version", "source_plugin", "contract_fingerprint", "health", "reason_code", "counts"}, set(projection))
+
+ def test_relationship_panel_source_cannot_return_sensitive_contract_fields(self) -> None:
+ source = (ROOT / "page_api.py").read_text(encoding="utf-8")
+ tree = ast.parse(source)
+ function = next(node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef) and node.name == "_relationship_panel")
+ string_constants = {node.value for node in ast.walk(function) if isinstance(node, ast.Constant) and type(node.value) is str}
+ forbidden = {"person_id", "p4_effect", "p4_live", "attestation", "raw_prompt", "memory_content", "group_overlay"}
+ self.assertTrue(forbidden.isdisjoint(string_constants))
+ self.assertIn("relationship_basis", string_constants)
+ self.assertIn("memory_phase", string_constants)
+ self.assertIn("reply_temperature", string_constants)
+
+ def test_extension_api_does_not_expose_p4_effect_or_live_authority(self) -> None:
+ source = (ROOT / "main.py").read_text(encoding="utf-8")
+ tree = ast.parse(source)
+ extension_api = next(
+ node for node in tree.body
+ if isinstance(node, ast.ClassDef) and node.name == "PrivateCompanionExtensionAPI"
+ )
+ public_methods = {
+ node.name for node in extension_api.body
+ if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+ }
+ forbidden = {"read_p4_effect_state", "read_p4_live_state", "record_p4_effect_event"}
+ self.assertTrue(forbidden.isdisjoint(public_methods))
+ self.assertIn("get_p6_readonly_status", public_methods)
+
+ def test_bridge_peek_degrades_for_missing_unsupported_invalid_and_exceptional_bridges(self) -> None:
+ # The plugin host is unavailable in the bundled test runtime. Stub
+ # only its logger namespace; no bridge is loaded or called externally.
+ astrbot = types.ModuleType("astrbot")
+ api = types.ModuleType("astrbot.api")
+ api.logger = types.SimpleNamespace(debug=lambda *args, **kwargs: None, warning=lambda *args, **kwargs: None)
+ sys.modules.setdefault("astrbot", astrbot)
+ sys.modules.setdefault("astrbot.api", api)
+ package = types.ModuleType("chat_companion_test_package")
+ package.__path__ = [str(ROOT)]
+ sys.modules.setdefault("chat_companion_test_package", package)
+ mixin = importlib.import_module("chat_companion_test_package.memory_companion_adapter").MemoryCompanionAdapterMixin
+
+ class Host(mixin):
+ def __init__(self, bridge: object) -> None:
+ self.bridge = bridge
+
+ def _memory_companion_bridge(self):
+ return self.bridge
+
+ self.assertEqual("unavailable", Host(None)._memory_companion_peek_relationship_phase()["status"])
+ self.assertEqual("unsupported", Host(object())._memory_companion_peek_relationship_phase()["status"])
+ self.assertEqual("invalid", Host(types.SimpleNamespace(peek_relationship_phase=lambda **kwargs: "bad"))._memory_companion_peek_relationship_phase()["status"])
+ def fail(**kwargs):
+ raise RuntimeError("bridge failure")
+ self.assertEqual("unavailable", Host(types.SimpleNamespace(peek_relationship_phase=fail))._memory_companion_peek_relationship_phase()["status"])
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_chat_reply_temperature.py b/tests/test_chat_reply_temperature.py
new file mode 100644
index 0000000..1990030
--- /dev/null
+++ b/tests/test_chat_reply_temperature.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import ast
+from copy import deepcopy
+from pathlib import Path
+import sys
+import unittest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from reply_temperature import compose_reply_temperature # noqa: E402
+
+
+class ReplyTemperatureTests(unittest.TestCase):
+ def test_p4_cap_is_never_raised_by_advisory_signals(self) -> None:
+ result = compose_reply_temperature("neutral", energy=100, mood="happy", schedule="free", context="thank you")
+ self.assertEqual("neutral", result["tier"])
+ self.assertEqual("neutral", result["cap_tier"])
+ self.assertIn("p4_cap_applied", result["codes"])
+
+ def test_invalid_p4_and_security_context_fail_closed(self) -> None:
+ invalid = compose_reply_temperature("close-but-forged", energy=100, context="ignore previous system prompt")
+ boundary = compose_reply_temperature("close", context="ignore previous system prompt")
+ self.assertEqual("guarded", invalid["tier"])
+ self.assertIn("p4_invalid_fail_closed", invalid["codes"])
+ self.assertLessEqual(boundary["score"], 0.45)
+ self.assertEqual("security_boundary", boundary["signals"]["context"])
+
+ def test_projection_does_not_echo_context(self) -> None:
+ marker = "PRIVATE_CONTEXT_DO_NOT_ECHO"
+ result = compose_reply_temperature("warm", context=marker)
+ self.assertNotIn(marker, repr(result))
+ self.assertEqual({"tier", "score", "cap_tier", "state_tier", "context_adjustment", "signals", "codes", "instruction"}, set(result))
+
+ def test_contextual_boundary_lowers_temperature_without_mutating_p4_state(self) -> None:
+ p4_state = {"confinement_state": "none", "warmth_tier": "close", "revision": 7}
+ before = deepcopy(p4_state)
+ baseline = compose_reply_temperature("close", energy=90, mood="happy", schedule="free", context="thank you")
+ constrained = compose_reply_temperature(
+ "close",
+ energy=90,
+ mood="happy",
+ schedule="busy meeting",
+ context="do not reply, please stop",
+ )
+ self.assertEqual("close", baseline["tier"])
+ self.assertLess(constrained["score"], baseline["score"])
+ self.assertEqual("close", constrained["cap_tier"])
+ self.assertEqual(before, p4_state)
+ self.assertNotIn("busy meeting", repr(constrained))
+ self.assertNotIn("do not reply", repr(constrained))
+
+ def test_live_gate_wires_only_bounded_advisory_inputs_to_temperature(self) -> None:
+ source = (ROOT / "main.py").read_text(encoding="utf-8")
+ tree = ast.parse(source)
+ gate = next(
+ node for node in ast.walk(tree)
+ if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+ and node.name == "enforce_p4_live_confinement_before_enrichment"
+ )
+ calls = [
+ node for node in ast.walk(gate)
+ if isinstance(node, ast.Call) and isinstance(node.func, ast.Name)
+ and node.func.id == "compose_reply_temperature"
+ ]
+ self.assertEqual(1, len(calls))
+ self.assertTrue(any(keyword.arg is None for keyword in calls[0].keywords))
+ helper = next(
+ node for node in ast.walk(tree)
+ if isinstance(node, ast.FunctionDef) and node.name == "_bounded_p4_reply_temperature_signals"
+ )
+ constants = {node.value for node in ast.walk(helper) if isinstance(node, ast.Constant) and type(node.value) is str}
+ self.assertTrue({"energy", "mood", "schedule", "context"}.issubset(constants))
+ self.assertNotIn("_private_companion_reply_temperature", constants)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/unified_person_registry.py b/unified_person_registry.py
index 3599729..11e09ae 100644
--- a/unified_person_registry.py
+++ b/unified_person_registry.py
@@ -12,6 +12,7 @@ from datetime import datetime, timezone
import hashlib
import json
import threading
+import re
from typing import Any
try:
@@ -23,6 +24,7 @@ try:
resolve_identity,
validate_projection,
)
+ from .p4_affinity_confinement import validate_runtime_state
except ImportError:
from person_context_contract import (
build_identity_key,
@@ -32,6 +34,7 @@ except ImportError:
resolve_identity,
validate_projection,
)
+ from p4_affinity_confinement import validate_runtime_state
_LOCK = threading.RLock()
@@ -43,6 +46,21 @@ _IDENTITY_FIELDS = (
"companion_instance_id", "bot_account_id", "adapter_instance_id",
"subject_namespace", "platform_subject_id",
)
+_P4_EFFECT_VERSION = 1
+_P4_EFFECT_ALLOWED_FIELDS = frozenset({
+ "event_id", "occurred_at", "kind", "source_kind", "target_kind", "authority",
+ "reason_code", "safe_reference", "safe_hash", "status", "shadow_only",
+})
+_P4_EFFECT_FORBIDDEN_FIELDS = frozenset({
+ "raw_prompt", "prompt", "text", "content", "chat_text", "messages", "transcript",
+ "private_object", "private_object_ref", "database", "db", "score", "penalty",
+ "confinement_state", "confinement_until", "authorized", "owner",
+})
+_P4_EFFECT_TOKEN_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:-]{0,79}\Z")
+_P4_EFFECT_TIMESTAMP_RE = re.compile(
+ r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}"
+ r"(?:\.[0-9]{1,6})?(?:Z|[+-][0-9]{2}:[0-9]{2})\Z"
+)
def _now() -> str:
@@ -119,6 +137,140 @@ def _fingerprint(value: Any) -> str:
return hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+def _contains_forbidden_key(value: Any) -> bool:
+ if type(value) is dict:
+ for key, item in value.items():
+ if type(key) is not str or key.strip().lower() in _P4_EFFECT_FORBIDDEN_FIELDS:
+ return True
+ if _contains_forbidden_key(item):
+ return True
+ return False
+ if type(value) in (list, tuple):
+ return any(_contains_forbidden_key(item) for item in value)
+ return False
+
+
+def _p4_effect_container(root: dict[str, Any]) -> dict[str, Any] | None:
+ """Return the separate preparation ledger, without repairing corruption."""
+ existing = root.get("p4_effect")
+ if existing is None:
+ existing = {"version": _P4_EFFECT_VERSION, "people": {}, "operations": {}}
+ root["p4_effect"] = existing
+ if not isinstance(existing, dict):
+ return None
+ if existing.get("version") != _P4_EFFECT_VERSION:
+ return None
+ if not isinstance(existing.get("people"), dict) or not isinstance(existing.get("operations"), dict):
+ return None
+ return existing
+
+
+def _normalize_p4_effect_event(event: Any) -> tuple[dict[str, Any] | None, str]:
+ if type(event) is not dict or _contains_forbidden_key(event):
+ return None, "invalid_p4_effect_event"
+ if any(type(key) is not str or key not in _P4_EFFECT_ALLOWED_FIELDS for key in event):
+ return None, "invalid_p4_effect_event"
+ if type(event.get("event_id")) is not str or _P4_EFFECT_TOKEN_RE.fullmatch(event["event_id"]) is None:
+ return None, "invalid_p4_effect_event"
+ occurred_at = event.get("occurred_at")
+ if type(occurred_at) is not str or _P4_EFFECT_TIMESTAMP_RE.fullmatch(occurred_at) is None:
+ return None, "invalid_p4_effect_event"
+ try:
+ parsed_occurred_at = datetime.fromisoformat(occurred_at.replace("Z", "+00:00"))
+ except (TypeError, ValueError, OverflowError):
+ return None, "invalid_p4_effect_event"
+ if parsed_occurred_at.tzinfo is None or parsed_occurred_at.utcoffset() is None:
+ return None, "invalid_p4_effect_event"
+ if type(event.get("kind")) is not str or _P4_EFFECT_TOKEN_RE.fullmatch(event["kind"]) is None:
+ return None, "invalid_p4_effect_event"
+ normalized: dict[str, Any] = {
+ "event_id": event["event_id"],
+ "occurred_at": occurred_at,
+ "kind": event["kind"],
+ }
+ for field in ("source_kind", "target_kind", "authority", "reason_code", "safe_reference"):
+ if field not in event:
+ continue
+ value = event[field]
+ if type(value) is type(None):
+ continue
+ if type(value) is not str:
+ return None, "invalid_p4_effect_event"
+ if value == "":
+ continue
+ if _P4_EFFECT_TOKEN_RE.fullmatch(value) is None:
+ return None, "invalid_p4_effect_event"
+ normalized[field] = value
+ if "safe_hash" in event:
+ safe_hash = event["safe_hash"]
+ if type(safe_hash) is not type(None):
+ if type(safe_hash) is not str:
+ return None, "invalid_p4_effect_event"
+ if safe_hash and re.fullmatch(r"sha256:[0-9a-f]{64}", safe_hash) is None:
+ return None, "invalid_p4_effect_event"
+ if safe_hash:
+ normalized["safe_hash"] = safe_hash
+ if "status" in event:
+ status = event.get("status")
+ if type(status) is not str or status not in {"shadow", "invalid", "degraded"}:
+ return None, "invalid_p4_effect_event"
+ normalized["status"] = status
+ if "shadow_only" in event:
+ if event.get("shadow_only") is not True:
+ return None, "invalid_p4_effect_event"
+ normalized["shadow_only"] = True
+ return normalized, ""
+
+
+def _p4_effect_fingerprint(person_id: str, event: dict[str, Any]) -> str:
+ return _fingerprint({"person_id": person_id, "event": event})
+
+
+def _p4_effect_state(events: list[dict[str, Any]]) -> dict[str, Any]:
+ last = events[-1] if events else {}
+ return {
+ "mode": "effect_preparation",
+ "event_count": len(events),
+ "last_event_id": str(last.get("event_id") or ""),
+ "last_kind": str(last.get("kind") or ""),
+ }
+
+
+def _p4_effect_summary(state: dict[str, Any]) -> dict[str, Any]:
+ return {
+ "mode": "effect_preparation",
+ "event_count": max(0, min(512, int(state.get("event_count") or 0))),
+ "last_kind": str(state.get("last_kind") or "")[:80],
+ }
+
+
+def _replay_p4_effect_entry(entry: Any, person_id: str) -> tuple[dict[str, Any] | None, dict[str, dict[str, Any]] | None, str]:
+ if type(entry) is not dict or entry.get("person_id") != person_id:
+ return None, None, "p4_effect_person_conflict"
+ events = entry.get("events")
+ if type(events) is not list or len(events) > 512:
+ return None, None, "p4_effect_corrupt"
+ normalized_events: list[dict[str, Any]] = []
+ event_index: dict[str, dict[str, Any]] = {}
+ for envelope in events:
+ if type(envelope) is not dict or set(envelope) != {"event_id", "person_id", "origin_person_id", "event", "event_fingerprint", "recorded_at", "operation_id"}:
+ return None, None, "p4_effect_corrupt"
+ if envelope.get("person_id") != person_id or type(envelope.get("origin_person_id")) is not str or not envelope["origin_person_id"]:
+ return None, None, "p4_effect_corrupt"
+ event, error = _normalize_p4_effect_event(envelope.get("event"))
+ if event is None or envelope.get("event_id") != event.get("event_id"):
+ return None, None, error or "p4_effect_corrupt"
+ event_id = event["event_id"]
+ if event_id in event_index or envelope.get("event_fingerprint") != _p4_effect_fingerprint(envelope["origin_person_id"], event):
+ return None, None, "p4_effect_corrupt"
+ event_index[event_id] = deepcopy(envelope)
+ normalized_events.append(event)
+ state = _p4_effect_state(normalized_events)
+ if entry.get("state") != state:
+ return None, None, "p4_effect_state_mismatch"
+ return state, event_index, ""
+
+
class UnifiedPersonRegistry:
"""The only chat-side writer for Unified Person identity state."""
@@ -145,6 +297,8 @@ class UnifiedPersonRegistry:
"profiles": len(profiles),
"identity_links": len(links),
"group_overlays": len(overlays),
+ "audit_events": len(root["audit_events"]),
+ "operations": len(root["operations"]),
}
def resolve(self, identity: dict[str, Any]) -> dict[str, Any]:
@@ -246,6 +400,280 @@ class UnifiedPersonRegistry:
projection = build_person_projection(self._store, str(person_id or ""))
return deepcopy(projection) if projection and not validate_projection(projection) else None
+ def read_p4_effect_state(self, person_id: str) -> dict[str, Any]:
+ """Read preparation state without creating a ledger or a person."""
+ try:
+ person_id = _text(person_id, "person_id")
+ except ValueError:
+ return {"ok": False, "code": "invalid_request", "person_id": ""}
+ with _LOCK:
+ root = _root(self._store)
+ profile = root["profiles"].get(person_id)
+ if not isinstance(profile, dict):
+ return {"ok": False, "code": "person_not_found", "person_id": person_id}
+ if profile.get("profile_status") != "active":
+ return {"ok": False, "code": "person_not_active", "person_id": person_id}
+ container = root.get("p4_effect")
+ if container is None:
+ state = _p4_effect_state([])
+ return {
+ "ok": True,
+ "code": "p4_effect_empty",
+ "person_id": person_id,
+ "p4_effect_exists": False,
+ "p4_effect_state": state,
+ "p4_effect_summary": _p4_effect_summary(state),
+ "event_count": 0,
+ }
+ if _p4_effect_container(root) is None:
+ return {"ok": False, "code": "p4_effect_corrupt", "person_id": person_id}
+ entry = container["people"].get(person_id)
+ if entry is None:
+ state = _p4_effect_state([])
+ return {
+ "ok": True,
+ "code": "p4_effect_empty",
+ "person_id": person_id,
+ "p4_effect_exists": False,
+ "p4_effect_state": state,
+ "p4_effect_summary": _p4_effect_summary(state),
+ "event_count": 0,
+ }
+ state, event_index, error = _replay_p4_effect_entry(entry, person_id)
+ if error or state is None or event_index is None:
+ return {"ok": False, "code": error or "p4_effect_corrupt", "person_id": person_id}
+ return {
+ "ok": True,
+ "code": "p4_effect_read",
+ "person_id": person_id,
+ "p4_effect_exists": True,
+ "p4_effect_state": state,
+ "p4_effect_summary": _p4_effect_summary(state),
+ "event_count": len(event_index),
+ }
+
+ def read_p4_live_state(self, person_id: str) -> dict[str, Any]:
+ """Read a separately-owned live state without creating or repairing it."""
+ try:
+ person_id = _text(person_id, "person_id")
+ except ValueError:
+ return {"ok": False, "code": "invalid_request", "person_id": ""}
+ with _LOCK:
+ root = _root(self._store)
+ profile = root["profiles"].get(person_id)
+ if not isinstance(profile, dict) or profile.get("profile_status") != "active":
+ return {"ok": False, "code": "person_not_active", "person_id": person_id}
+ container = root.get("p4_live")
+ if container is None:
+ return {"ok": True, "code": "p4_live_state_absent", "person_id": person_id, "state": None}
+ if type(container) is not dict or container.get("version") != 1 or type(container.get("people")) is not dict:
+ return {"ok": False, "code": "p4_live_state_corrupt", "person_id": person_id}
+ state = container["people"].get(person_id)
+ if state is None:
+ return {"ok": True, "code": "p4_live_state_absent", "person_id": person_id, "state": None}
+ if type(state) is not dict:
+ return {"ok": False, "code": "p4_live_state_corrupt", "person_id": person_id}
+ return {"ok": True, "code": "p4_live_state_read", "person_id": person_id, "state": deepcopy(state)}
+
+ def record_p4_live_state(
+ self,
+ person_id: str,
+ state: dict[str, Any],
+ *,
+ operation_id: str,
+ actor_id: str = "companion",
+ ) -> dict[str, Any]:
+ """Persist only an exact Companion-owned runtime state with replay safety."""
+ try:
+ person_id = _text(person_id, "person_id")
+ operation_id = _text(operation_id, "operation_id", 120)
+ actor_id = _text(actor_id, "actor_id", 120)
+ except ValueError:
+ return {"ok": False, "code": "invalid_request"}
+ if actor_id != "companion" or validate_runtime_state(state) == "invalid":
+ return {"ok": False, "code": "p4_live_state_rejected", "person_id": person_id, "operation_id": operation_id}
+ copied_state = deepcopy(state)
+ request_fingerprint = _fingerprint({"person_id": person_id, "state": copied_state, "actor_id": actor_id})
+ with _LOCK:
+ root = _root(self._store)
+ profile = root["profiles"].get(person_id)
+ if not isinstance(profile, dict) or profile.get("profile_status") != "active":
+ return {"ok": False, "code": "person_not_active", "person_id": person_id, "operation_id": operation_id}
+ container = root.get("p4_live")
+ if container is None:
+ container = {"version": 1, "people": {}, "operations": {}}
+ root["p4_live"] = container
+ if (
+ type(container) is not dict
+ or container.get("version") != 1
+ or type(container.get("people")) is not dict
+ or type(container.get("operations")) is not dict
+ ):
+ return {"ok": False, "code": "p4_live_state_corrupt", "person_id": person_id, "operation_id": operation_id}
+ prior = container["operations"].get(operation_id)
+ if isinstance(prior, dict):
+ if prior.get("request_fingerprint") != request_fingerprint:
+ return {"ok": False, "code": "operation_id_conflict", "person_id": person_id, "operation_id": operation_id}
+ result = deepcopy(prior.get("result"))
+ if isinstance(result, dict):
+ result["idempotent"] = True
+ return result
+ return {"ok": False, "code": "p4_live_state_corrupt", "person_id": person_id, "operation_id": operation_id}
+ container["people"][person_id] = copied_state
+ result = {"ok": True, "code": "p4_live_state_recorded", "person_id": person_id, "operation_id": operation_id, "changed": True}
+ container["operations"][operation_id] = {"request_fingerprint": request_fingerprint, "result": deepcopy(result)}
+ root["audit_events"].append({"event_id": operation_id, "action": "p4_live_state_recorded", "actor_id": actor_id, "person_id": person_id, "at": _now()})
+ root["audit_events"] = root["audit_events"][-1000:]
+ return result
+
+ def record_p4_effect_event(
+ self,
+ person_id: str,
+ event: dict[str, Any],
+ *,
+ operation_id: str,
+ actor_id: str = "system",
+ ) -> dict[str, Any]:
+ """Append a replayable preparation event without enabling a live effect."""
+ try:
+ person_id = _text(person_id, "person_id")
+ operation_id = _text(operation_id, "operation_id", 120)
+ actor_id = _text(actor_id, "actor_id", 120)
+ except ValueError:
+ return {"ok": False, "code": "invalid_request"}
+ normalized_event, error = _normalize_p4_effect_event(event)
+ if normalized_event is None:
+ return {"ok": False, "code": error or "invalid_p4_effect_event", "person_id": person_id, "operation_id": operation_id}
+ payload_fingerprint = _fingerprint({"person_id": person_id, "event": normalized_event, "actor_id": actor_id})
+ with _LOCK:
+ root = _root(self._store)
+ profile = root["profiles"].get(person_id)
+ if not isinstance(profile, dict):
+ return {"ok": False, "code": "person_not_found", "person_id": person_id, "operation_id": operation_id}
+ if profile.get("profile_status") != "active":
+ return {"ok": False, "code": "person_not_active", "person_id": person_id, "operation_id": operation_id}
+ container = _p4_effect_container(root)
+ if container is None:
+ return {"ok": False, "code": "p4_effect_corrupt", "person_id": person_id, "operation_id": operation_id}
+ previous_operation = container["operations"].get(operation_id)
+ if isinstance(previous_operation, dict):
+ if previous_operation.get("request_fingerprint") != payload_fingerprint:
+ return {"ok": False, "code": "operation_id_conflict", "person_id": person_id, "operation_id": operation_id}
+ result = deepcopy(previous_operation.get("result") or {})
+ if isinstance(result, dict):
+ result["idempotent"] = True
+ return result
+ return {"ok": False, "code": "p4_effect_corrupt", "person_id": person_id, "operation_id": operation_id}
+
+ people = container["people"]
+ entry = people.get(person_id)
+ if entry is None:
+ now = _now()
+ entry = {
+ "person_id": person_id,
+ "state": _p4_effect_state([]),
+ "events": [],
+ "created_at": now,
+ "updated_at": now,
+ "last_operation_id": "",
+ }
+ state, event_index, replay_error = _replay_p4_effect_entry(entry, person_id) if entry else (_p4_effect_state([]), {}, "")
+ if replay_error or state is None or event_index is None:
+ return {"ok": False, "code": replay_error or "p4_effect_corrupt", "person_id": person_id, "operation_id": operation_id}
+ event_id = normalized_event["event_id"]
+ fingerprint = _p4_effect_fingerprint(person_id, normalized_event)
+ known = event_index.get(event_id)
+ if known is not None:
+ if known.get("event_fingerprint") != fingerprint:
+ return {"ok": False, "code": "p4_effect_event_id_conflict", "person_id": person_id, "event_id": event_id, "operation_id": operation_id}
+ result = {
+ "ok": True,
+ "code": "p4_effect_event_duplicate",
+ "person_id": person_id,
+ "event_id": event_id,
+ "operation_id": operation_id,
+ "event_duplicate": True,
+ "p4_effect_summary": _p4_effect_summary(state),
+ "live_effect_permitted": False,
+ }
+ container["operations"][operation_id] = {"request_fingerprint": payload_fingerprint, "result": deepcopy(result)}
+ return result
+ now = _now()
+ entry["events"].append({
+ "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,
+ })
+ replay_state = _p4_effect_state([item["event"] for item in entry["events"]])
+ entry["state"] = replay_state
+ entry["updated_at"] = now
+ entry["last_operation_id"] = operation_id
+ people[person_id] = entry
+ root["audit_events"].append({
+ "event_id": operation_id,
+ "action": "p4_effect_event_recorded",
+ "actor_id": actor_id,
+ "person_id": person_id,
+ "at": now,
+ "kind": normalized_event["kind"],
+ })
+ root["audit_events"] = root["audit_events"][-1000:]
+ result = {
+ "ok": True,
+ "code": "p4_effect_event_recorded",
+ "person_id": person_id,
+ "event_id": event_id,
+ "operation_id": operation_id,
+ "changed": True,
+ "affected_person_ids": [person_id],
+ "p4_effect_summary": _p4_effect_summary(replay_state),
+ "live_effect_permitted": False,
+ }
+ container["operations"][operation_id] = {"request_fingerprint": payload_fingerprint, "result": deepcopy(result)}
+ return result
+
+ def guard_p4_effect_person_transition(
+ self,
+ action: str,
+ source_person_id: str,
+ target_person_id: str,
+ *,
+ operation_id: str,
+ ) -> dict[str, Any]:
+ """Reject unsupported identity merge/split before it can touch the P4 ledger.
+
+ Chat-side Unified Person deliberately has no person-lifecycle merge or
+ split operation. A future caller must implement an explicit replay
+ migration rather than silently reassigning preparation entries.
+ """
+ try:
+ action = _text(action, "action", 40)
+ source_person_id = _text(source_person_id, "source_person_id")
+ target_person_id = _text(target_person_id, "target_person_id")
+ operation_id = _text(operation_id, "operation_id", 120)
+ except ValueError:
+ return {"ok": False, "code": "invalid_request"}
+ if action not in {"merge", "split"} or source_person_id == target_person_id:
+ return {"ok": False, "code": "p4_effect_transition_rejected", "operation_id": operation_id}
+ with _LOCK:
+ # Do not call the P4 container helper here: creating or repairing
+ # a ledger would itself violate the no-transition guarantee.
+ root = _root(self._store)
+ source = root["profiles"].get(source_person_id)
+ target = root["profiles"].get(target_person_id)
+ if not isinstance(source, dict) or not isinstance(target, dict):
+ return {"ok": False, "code": "p4_effect_transition_person_not_found", "operation_id": operation_id}
+ return {
+ "ok": False,
+ "code": "p4_effect_transition_unsupported",
+ "operation_id": operation_id,
+ "action": action,
+ }
+
def upsert_group_overlay(self, person_id: str, group_scope: str, overlay: dict[str, Any], operation_id: str = "", actor_id: str = "companion", **_: Any) -> dict[str, Any]:
try:
person_id, group_scope, op = _text(person_id, "person_id"), _text(group_scope, "group_scope", 240), _operation_id(operation_id)