feat(p4): add host-bound manual review queue
这个提交存在于:
父节点
f02430a39a
当前提交
c6dd3e769a
共有 7 个文件被更改,包括 2213 次插入 和 3 次删除
|
|
@ -9188,12 +9188,23 @@
|
||||||
"p4_b_safety_config": {
|
"p4_b_safety_config": {
|
||||||
"description": "P4-B 实效前置隔离门",
|
"description": "P4-B 实效前置隔离门",
|
||||||
"type": "object",
|
"type": "object",
|
||||||
"hint": "默认关闭以保持旧版本兼容。开启后只隔离旧 relationship_score 直写,不启用 P4 实效、禁闭或 owner 命令。",
|
"hint": "默认关闭以保持旧版本兼容。人工审核仅记录独立队列和审计,不启用 P4 实效、禁闭、释放、恢复或 owner 命令。owner 白名单必须与 AstrBot event.get_sender_id() 运行时身份同时匹配。",
|
||||||
"items": {
|
"items": {
|
||||||
"enable_p4_b_legacy_score_isolation": {
|
"enable_p4_b_legacy_score_isolation": {
|
||||||
"description": "隔离旧关系分直写",
|
"description": "隔离旧关系分直写",
|
||||||
"type": "bool",
|
"type": "bool",
|
||||||
"default": false
|
"default": false
|
||||||
|
},
|
||||||
|
"enable_p4_manual_review": {
|
||||||
|
"description": "启用 P4 人工审核候选观察与审计入口",
|
||||||
|
"type": "bool",
|
||||||
|
"default": false
|
||||||
|
},
|
||||||
|
"p4_manual_review_owner_ids": {
|
||||||
|
"description": "P4 人工审核 owner ID 白名单",
|
||||||
|
"type": "list",
|
||||||
|
"hint": "仅作 allowlist;运行时仍必须由 AstrBot event.get_sender_id() 返回相同单行 ID。兼容逗号或空白分隔字符串,不能用页面、请求、模型文本或事件字段自证授权。",
|
||||||
|
"default": []
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|
|
||||||
|
|
@ -623,6 +623,10 @@ class CoreStoreMixin:
|
||||||
return self._unified_person_registry().audit_events(limit=limit)
|
return self._unified_person_registry().audit_events(limit=limit)
|
||||||
|
|
||||||
def _apply_unified_person_lifecycle(self, method: str, *args: Any, **kwargs: Any) -> dict[str, Any]:
|
def _apply_unified_person_lifecycle(self, method: str, *args: Any, **kwargs: Any) -> dict[str, Any]:
|
||||||
|
if method in {"record_p4_manual_review_candidate", "record_p4_manual_review_decision"} and not bool(
|
||||||
|
getattr(self, "enable_p4_manual_review", False)
|
||||||
|
):
|
||||||
|
return {"ok": False, "code": "p4_review_disabled", "live_effect_permitted": False}
|
||||||
registry = self._unified_person_registry()
|
registry = self._unified_person_registry()
|
||||||
operation = getattr(registry, method, None)
|
operation = getattr(registry, method, None)
|
||||||
if not callable(operation) or method not in {
|
if not callable(operation) or method not in {
|
||||||
|
|
@ -633,6 +637,8 @@ class CoreStoreMixin:
|
||||||
"split_merged_people",
|
"split_merged_people",
|
||||||
"record_p4_shadow_event",
|
"record_p4_shadow_event",
|
||||||
"record_p4_effect_event",
|
"record_p4_effect_event",
|
||||||
|
"record_p4_manual_review_candidate",
|
||||||
|
"record_p4_manual_review_decision",
|
||||||
}:
|
}:
|
||||||
return {"ok": False, "code": "unsupported_lifecycle_operation"}
|
return {"ok": False, "code": "unsupported_lifecycle_operation"}
|
||||||
result = operation(*args, **kwargs)
|
result = operation(*args, **kwargs)
|
||||||
|
|
|
||||||
217
main.py
217
main.py
|
|
@ -18,7 +18,7 @@ import time
|
||||||
import unicodedata
|
import unicodedata
|
||||||
import zoneinfo
|
import zoneinfo
|
||||||
from copy import deepcopy
|
from copy import deepcopy
|
||||||
from datetime import date, datetime, timedelta
|
from datetime import date, datetime, timedelta, timezone
|
||||||
from email.utils import parsedate_to_datetime
|
from email.utils import parsedate_to_datetime
|
||||||
from http.cookies import SimpleCookie
|
from http.cookies import SimpleCookie
|
||||||
from pathlib import Path
|
from pathlib import Path
|
||||||
|
|
@ -142,6 +142,14 @@ from .p5_provenance_attestation import FIREWALL_STATUSES, P5AttestationRegistry
|
||||||
from .p5c_gate import RAW_IMAGE_PROVIDER_SINK, p5c_gate_allows
|
from .p5c_gate import RAW_IMAGE_PROVIDER_SINK, p5c_gate_allows
|
||||||
from .p5d_security_events import p5d_security_event_allows
|
from .p5d_security_events import p5d_security_event_allows
|
||||||
from .p6_readonly_projection import build_p6_readonly_status
|
from .p6_readonly_projection import build_p6_readonly_status
|
||||||
|
from .p4_manual_review import (
|
||||||
|
build_p3_review_proof,
|
||||||
|
_new_p4_review_attestation_registry,
|
||||||
|
P4ReviewAttestationRegistry,
|
||||||
|
parse_owner_allowlist,
|
||||||
|
runtime_owner_identity,
|
||||||
|
runtime_scope_identity,
|
||||||
|
)
|
||||||
from .segmented_message import flatten_component_chunks, split_plain_component_chain_detailed
|
from .segmented_message import flatten_component_chunks, split_plain_component_chain_detailed
|
||||||
from .token_budget import TokenBudgetMixin
|
from .token_budget import TokenBudgetMixin
|
||||||
from .balance_awareness import BalanceAwarenessMixin
|
from .balance_awareness import BalanceAwarenessMixin
|
||||||
|
|
@ -199,6 +207,9 @@ from .planning import (
|
||||||
)
|
)
|
||||||
|
|
||||||
P4_SHADOW_OBSERVER_PRIORITY = FINALIZE - 1000
|
P4_SHADOW_OBSERVER_PRIORITY = FINALIZE - 1000
|
||||||
|
# P4 manual review is a distinct, default-off observer after P3 finalization.
|
||||||
|
# Its queue is deliberately independent from both P4-A shadow and P4-B effect.
|
||||||
|
P4_MANUAL_REVIEW_OBSERVER_PRIORITY = P4_SHADOW_OBSERVER_PRIORITY - 1
|
||||||
# P5-A must publish source disposition before MemoryCompanion's P3 hook (-20),
|
# P5-A must publish source disposition before MemoryCompanion's P3 hook (-20),
|
||||||
# but after the companion context has assembled its known prompt sources.
|
# but after the companion context has assembled its known prompt sources.
|
||||||
P5_SOURCE_OBSERVER_PRIORITY = MEMORY_CONTEXT + 1
|
P5_SOURCE_OBSERVER_PRIORITY = MEMORY_CONTEXT + 1
|
||||||
|
|
@ -1945,6 +1956,13 @@ class PrivateCompanionPlugin(
|
||||||
# legacy direct score writes while the separate effect ledger is
|
# legacy direct score writes while the separate effect ledger is
|
||||||
# prepared and remains default-off for rollback compatibility.
|
# prepared and remains default-off for rollback compatibility.
|
||||||
self.enable_p4_b_legacy_score_isolation = self._cfg_bool(c, "enable_p4_b_legacy_score_isolation", False)
|
self.enable_p4_b_legacy_score_isolation = self._cfg_bool(c, "enable_p4_b_legacy_score_isolation", False)
|
||||||
|
# Manual P4 review is independently default-off. These configured
|
||||||
|
# IDs are an allowlist only; the review write path always obtains its
|
||||||
|
# actor from the actual AstrBot event.get_sender_id() runtime call.
|
||||||
|
self.enable_p4_manual_review = self._cfg_bool(c, "enable_p4_manual_review", False)
|
||||||
|
self.p4_manual_review_owner_ids = parse_owner_allowlist(
|
||||||
|
self._cfg_raw(c, "p4_manual_review_owner_ids", [])
|
||||||
|
)
|
||||||
# P5-A only observes source metadata. It never rewrites a prompt,
|
# P5-A only observes source metadata. It never rewrites a prompt,
|
||||||
# changes a live tool set, or changes retrieval/response behaviour.
|
# changes a live tool set, or changes retrieval/response behaviour.
|
||||||
self.enable_p5_source_observer = self._cfg_bool(c, "enable_p5_source_observer", False)
|
self.enable_p5_source_observer = self._cfg_bool(c, "enable_p5_source_observer", False)
|
||||||
|
|
@ -8322,7 +8340,10 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
|
||||||
def _safe_event_sender_id(event: AstrMessageEvent | None) -> str:
|
def _safe_event_sender_id(event: AstrMessageEvent | None) -> str:
|
||||||
if event is None:
|
if event is None:
|
||||||
return ""
|
return ""
|
||||||
getter = getattr(event, "get_sender_id", None)
|
try:
|
||||||
|
getter = getattr(event, "get_sender_id", None)
|
||||||
|
except Exception:
|
||||||
|
return ""
|
||||||
if callable(getter):
|
if callable(getter):
|
||||||
try:
|
try:
|
||||||
return _single_line(getter(), 80)
|
return _single_line(getter(), 80)
|
||||||
|
|
@ -9897,6 +9918,75 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
|
||||||
"""Expose the P5-D reject-only boundary without creating a live hook."""
|
"""Expose the P5-D reject-only boundary without creating a live hook."""
|
||||||
return p5d_security_event_allows(self, operation, *opaque)
|
return p5d_security_event_allows(self, operation, *opaque)
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def _p4_manual_review_runtime_sender_id(event: AstrMessageEvent | None) -> str:
|
||||||
|
"""Read a sender only from AstrBot's direct runtime API, never fields."""
|
||||||
|
if event is None:
|
||||||
|
return ""
|
||||||
|
try:
|
||||||
|
getter = getattr(event, "get_sender_id", None)
|
||||||
|
except Exception:
|
||||||
|
return ""
|
||||||
|
if not callable(getter):
|
||||||
|
return ""
|
||||||
|
try:
|
||||||
|
return _single_line(getter(), 160)
|
||||||
|
except Exception:
|
||||||
|
return ""
|
||||||
|
|
||||||
|
def _p4_manual_review_owner_runtime_identity(self, event: AstrMessageEvent | None) -> dict[str, Any]:
|
||||||
|
"""Expose the P4 owner double gate without treating config as a credential."""
|
||||||
|
return runtime_owner_identity(event, getattr(self, "p4_manual_review_owner_ids", ()))
|
||||||
|
|
||||||
|
def _p4_manual_review_attestation_registry(self) -> P4ReviewAttestationRegistry:
|
||||||
|
"""Return the host-owned, one-shot P3 observer attestation issuer."""
|
||||||
|
registry = getattr(self, "_p4_manual_review_registry", None)
|
||||||
|
if isinstance(registry, P4ReviewAttestationRegistry):
|
||||||
|
return registry
|
||||||
|
registry = _new_p4_review_attestation_registry()
|
||||||
|
setattr(self, "_p4_manual_review_registry", registry)
|
||||||
|
return registry
|
||||||
|
|
||||||
|
def submit_p4_manual_review_decision(
|
||||||
|
self,
|
||||||
|
event: AstrMessageEvent | None,
|
||||||
|
*,
|
||||||
|
person_id: str,
|
||||||
|
candidate_id: str,
|
||||||
|
operation_id: str,
|
||||||
|
decision: str,
|
||||||
|
reason_code: str,
|
||||||
|
) -> dict[str, Any]:
|
||||||
|
"""Write an audit-only manual P4 conclusion through the runtime gate.
|
||||||
|
|
||||||
|
This is an explicit host/API seam, not a model command, page action,
|
||||||
|
or automatic effect. The registry repeats the direct event identity
|
||||||
|
proof so a caller cannot bypass this method through a forged payload.
|
||||||
|
"""
|
||||||
|
if not bool(getattr(self, "enable_p4_manual_review", False)):
|
||||||
|
return {"ok": False, "code": "p4_review_disabled", "live_effect_permitted": False}
|
||||||
|
owner = self._p4_manual_review_owner_runtime_identity(event)
|
||||||
|
if owner.get("accepted") is not True:
|
||||||
|
return {
|
||||||
|
"ok": False,
|
||||||
|
"code": str(owner.get("code") or "p4_review_owner_runtime_unavailable"),
|
||||||
|
"live_effect_permitted": False,
|
||||||
|
}
|
||||||
|
try:
|
||||||
|
return self._apply_unified_person_lifecycle(
|
||||||
|
"record_p4_manual_review_decision",
|
||||||
|
event,
|
||||||
|
getattr(self, "p4_manual_review_owner_ids", ()),
|
||||||
|
person_id,
|
||||||
|
candidate_id,
|
||||||
|
operation_id=operation_id,
|
||||||
|
decision=decision,
|
||||||
|
reason_code=reason_code,
|
||||||
|
)
|
||||||
|
except Exception as exc:
|
||||||
|
logger.debug("[PrivateCompanion] P4 manual review decision rejected: %s", _single_line(exc, 160))
|
||||||
|
return {"ok": False, "code": "p4_review_runtime_error", "live_effect_permitted": False}
|
||||||
|
|
||||||
def _p4_b_apply_legacy_relationship_delta(
|
def _p4_b_apply_legacy_relationship_delta(
|
||||||
self,
|
self,
|
||||||
user: Any,
|
user: Any,
|
||||||
|
|
@ -10390,6 +10480,129 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge
|
||||||
_single_line(result.get("code") if isinstance(result, dict) else "", 120) or "unknown",
|
_single_line(result.get("code") if isinstance(result, dict) else "", 120) or "unknown",
|
||||||
)
|
)
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def _p4_manual_review_expiry(created_at: str) -> str:
|
||||||
|
"""Return the fixed observer queue TTL, or an empty value on failure."""
|
||||||
|
if not isinstance(created_at, str) or not created_at:
|
||||||
|
return ""
|
||||||
|
try:
|
||||||
|
parsed = datetime.fromisoformat(
|
||||||
|
created_at[:-1] + "+00:00" if created_at.endswith("Z") else created_at
|
||||||
|
)
|
||||||
|
except (TypeError, ValueError):
|
||||||
|
return ""
|
||||||
|
if parsed.tzinfo is None:
|
||||||
|
return ""
|
||||||
|
return (parsed.astimezone(timezone.utc) + timedelta(hours=24)).isoformat(timespec="seconds").replace("+00:00", "Z")
|
||||||
|
|
||||||
|
@filter.on_llm_request(priority=P4_MANUAL_REVIEW_OBSERVER_PRIORITY)
|
||||||
|
async def observe_p4_manual_review_candidate(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs):
|
||||||
|
"""Queue a P3-finalized candidate only; never settle any P4 effect."""
|
||||||
|
if self is None or event is None or req is None:
|
||||||
|
return
|
||||||
|
if not bool(getattr(self, "enable_p4_manual_review", False)):
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
state = read_context_state(request=req, event=event)
|
||||||
|
except Exception:
|
||||||
|
return
|
||||||
|
if not isinstance(state, dict) or state.get("phase") != "finalized" or state.get("finalized") is not True:
|
||||||
|
return
|
||||||
|
security = state.get("security")
|
||||||
|
if not isinstance(security, dict) or security.get("status") not in {"allowed", "sanitized"}:
|
||||||
|
return
|
||||||
|
if security.get("response_policy") == "deny":
|
||||||
|
return
|
||||||
|
created_at = state.get("created_at")
|
||||||
|
expires_at = self._p4_manual_review_expiry(created_at)
|
||||||
|
if not isinstance(created_at, str) or not expires_at:
|
||||||
|
return
|
||||||
|
# The target identity must also be rooted in the direct AstrBot getter;
|
||||||
|
# never fall back to event fields, P3 carrier values, or request data.
|
||||||
|
sender_id = self._p4_manual_review_runtime_sender_id(event)
|
||||||
|
if not sender_id:
|
||||||
|
return
|
||||||
|
scope = runtime_scope_identity(event)
|
||||||
|
scope_kind = str(scope.get("scope_kind") or "")
|
||||||
|
scope_id = str(scope.get("scope_id") or "")
|
||||||
|
if not scope_kind or not scope_id:
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
message_id = self._event_message_id(event)
|
||||||
|
except Exception:
|
||||||
|
return
|
||||||
|
if not message_id:
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
authority = self._memory_companion_unified_person_authority(
|
||||||
|
event,
|
||||||
|
expected_user_id=sender_id,
|
||||||
|
)
|
||||||
|
except Exception:
|
||||||
|
return
|
||||||
|
projection = authority.get("unified_person_projection") if isinstance(authority, dict) else None
|
||||||
|
source_identity = authority.get("unified_person_source_identity") if isinstance(authority, dict) else None
|
||||||
|
if not isinstance(projection, dict) or not isinstance(source_identity, dict):
|
||||||
|
return
|
||||||
|
person_id = _single_line(projection.get("person_id"), 160)
|
||||||
|
assurance = projection.get("identity_assurance")
|
||||||
|
if (
|
||||||
|
not person_id
|
||||||
|
or projection.get("profile_status") != "active"
|
||||||
|
or assurance not in {"verified", "explicit_linked"}
|
||||||
|
):
|
||||||
|
return
|
||||||
|
p3_proof = build_p3_review_proof(
|
||||||
|
state,
|
||||||
|
person_id=person_id,
|
||||||
|
identity_assurance=assurance,
|
||||||
|
scope_kind=scope_kind,
|
||||||
|
scope_id=scope_id,
|
||||||
|
)
|
||||||
|
if p3_proof is None:
|
||||||
|
return
|
||||||
|
digest = hashlib.sha256(message_id.encode("utf-8", errors="ignore")).hexdigest()
|
||||||
|
candidate = {
|
||||||
|
"candidate_id": f"p4.review.candidate:{digest}",
|
||||||
|
"event_id": f"p4.review.event:{digest}",
|
||||||
|
"person_id": person_id,
|
||||||
|
"created_at": created_at,
|
||||||
|
"expires_at": expires_at,
|
||||||
|
"reason_code": "p3_finalized_observed",
|
||||||
|
"scope_kind": scope_kind,
|
||||||
|
"scope_id": scope_id,
|
||||||
|
"p3_proof": p3_proof,
|
||||||
|
}
|
||||||
|
operation_id = f"p4.review.candidate:{person_id}:{digest}"
|
||||||
|
try:
|
||||||
|
producer_attestation = self._p4_manual_review_attestation_registry().mint(
|
||||||
|
req,
|
||||||
|
event,
|
||||||
|
state,
|
||||||
|
candidate,
|
||||||
|
operation_id=operation_id,
|
||||||
|
)
|
||||||
|
if producer_attestation is None:
|
||||||
|
return
|
||||||
|
result = self._apply_unified_person_lifecycle(
|
||||||
|
"record_p4_manual_review_candidate",
|
||||||
|
person_id,
|
||||||
|
candidate,
|
||||||
|
operation_id=operation_id,
|
||||||
|
producer_attestation=producer_attestation,
|
||||||
|
producer_request=req,
|
||||||
|
producer_event=event,
|
||||||
|
producer_state=state,
|
||||||
|
)
|
||||||
|
except Exception as exc:
|
||||||
|
logger.debug("[PrivateCompanion] P4 manual review candidate skipped: %s", _single_line(exc, 160))
|
||||||
|
return
|
||||||
|
if not isinstance(result, dict) or not result.get("ok"):
|
||||||
|
logger.debug(
|
||||||
|
"[PrivateCompanion] P4 manual review candidate rejected: code=%s",
|
||||||
|
_single_line(result.get("code") if isinstance(result, dict) else "", 120) or "unknown",
|
||||||
|
)
|
||||||
|
|
||||||
@filter.on_llm_response()
|
@filter.on_llm_response()
|
||||||
async def normalize_tts_enhancement_response(self, event: AstrMessageEvent, resp: LLMResponse, *args, **kwargs):
|
async def normalize_tts_enhancement_response(self, event: AstrMessageEvent, resp: LLMResponse, *args, **kwargs):
|
||||||
"""恢复降级为正文的生图调用,并规范化 TTS 标签。"""
|
"""恢复降级为正文的生图调用,并规范化 TTS 标签。"""
|
||||||
|
|
|
||||||
864
p4_manual_review.py
普通文件
864
p4_manual_review.py
普通文件
|
|
@ -0,0 +1,864 @@
|
||||||
|
# -*- coding: utf-8 -*-
|
||||||
|
"""Default-off P4 manual-review contracts and isolated queue helpers.
|
||||||
|
|
||||||
|
This module intentionally knows nothing about P4 shadow settlement, P4 effect
|
||||||
|
preparation, model output, pages, request carriers, or live enforcement. A
|
||||||
|
review decision is only an audited queue record; it never causes a punishment,
|
||||||
|
release, recovery, reply, or memory write.
|
||||||
|
"""
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from copy import deepcopy
|
||||||
|
from dataclasses import dataclass
|
||||||
|
from datetime import datetime, timezone
|
||||||
|
import hashlib
|
||||||
|
import json
|
||||||
|
import re
|
||||||
|
import threading
|
||||||
|
import time
|
||||||
|
import unicodedata
|
||||||
|
from typing import Any
|
||||||
|
|
||||||
|
try:
|
||||||
|
from .context_orchestration import (
|
||||||
|
CONTRACT_NAME as P3_CONTRACT_NAME,
|
||||||
|
CONTRACT_VERSION as P3_CONTRACT_VERSION,
|
||||||
|
LAYERS as P3_LAYERS,
|
||||||
|
contract_fingerprint as p3_contract_fingerprint,
|
||||||
|
)
|
||||||
|
except ImportError:
|
||||||
|
from context_orchestration import (
|
||||||
|
CONTRACT_NAME as P3_CONTRACT_NAME,
|
||||||
|
CONTRACT_VERSION as P3_CONTRACT_VERSION,
|
||||||
|
LAYERS as P3_LAYERS,
|
||||||
|
contract_fingerprint as p3_contract_fingerprint,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
P4_REVIEW_VERSION = 1
|
||||||
|
P4_REVIEW_ALLOWED_SECURITY_STATUSES = frozenset({"allowed", "sanitized"})
|
||||||
|
P4_REVIEW_ALLOWED_ASSURANCES = frozenset({"verified", "explicit_linked"})
|
||||||
|
P4_REVIEW_ALLOWED_DECISIONS = frozenset({"approve", "reject"})
|
||||||
|
P4_REVIEW_ALLOWED_POLICIES = frozenset({"inherit", "allow"})
|
||||||
|
|
||||||
|
_MAX_ID_LENGTH = 160
|
||||||
|
_MAX_REASON_LENGTH = 120
|
||||||
|
_REASON_RE = re.compile(r"[a-z0-9][a-z0-9_.:-]{0,119}\Z")
|
||||||
|
_OWNER_PLACEHOLDERS = frozenset({"", "none", "null", "undefined", "default"})
|
||||||
|
_ATTESTATION_CREATION_TOKEN = object()
|
||||||
|
_HANDLE_CREATION_TOKEN = object()
|
||||||
|
P4_REVIEW_ATTESTATION_DEFAULT_TTL_SECONDS = 30.0
|
||||||
|
P4_REVIEW_ATTESTATION_MAX_ENTRIES = 1024
|
||||||
|
|
||||||
|
|
||||||
|
class P4ReviewProducerAttestationHandle:
|
||||||
|
"""Opaque, non-serializable, one-shot P3 observer attestation."""
|
||||||
|
|
||||||
|
__slots__ = ("_registry",)
|
||||||
|
|
||||||
|
def __init__(self, creation_token: object, registry: object) -> None:
|
||||||
|
if creation_token is not _HANDLE_CREATION_TOKEN:
|
||||||
|
raise TypeError("P4 review attestations are minted only by the host registry")
|
||||||
|
self._registry = registry
|
||||||
|
|
||||||
|
def __reduce__(self) -> object:
|
||||||
|
raise TypeError("P4 review attestations cannot be serialized")
|
||||||
|
|
||||||
|
def __reduce_ex__(self, protocol: int) -> object:
|
||||||
|
raise TypeError("P4 review attestations cannot be serialized")
|
||||||
|
|
||||||
|
def __getstate__(self) -> object:
|
||||||
|
raise TypeError("P4 review attestations cannot be serialized")
|
||||||
|
|
||||||
|
def __repr__(self) -> str:
|
||||||
|
return "<P4ReviewProducerAttestationHandle opaque>"
|
||||||
|
|
||||||
|
def __init_subclass__(cls, **kwargs: object) -> None:
|
||||||
|
raise TypeError("P4 review attestations cannot be subclassed")
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(slots=True)
|
||||||
|
class _ProducerAttestationEntry:
|
||||||
|
request: object
|
||||||
|
event: object
|
||||||
|
p3_state: object
|
||||||
|
candidate_fingerprint: str
|
||||||
|
candidate_id: str
|
||||||
|
event_id: str
|
||||||
|
person_id: str
|
||||||
|
scope_kind: str
|
||||||
|
scope_id: str
|
||||||
|
operation_id: str
|
||||||
|
expires_at: float
|
||||||
|
|
||||||
|
|
||||||
|
class P4ReviewAttestationRegistry:
|
||||||
|
"""Host-owned bounded issuer for exact-carrier, one-shot P4 review handles."""
|
||||||
|
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
creation_token: object | None = None,
|
||||||
|
*,
|
||||||
|
clock: Any | None = None,
|
||||||
|
default_ttl_seconds: float = P4_REVIEW_ATTESTATION_DEFAULT_TTL_SECONDS,
|
||||||
|
max_entries: int = P4_REVIEW_ATTESTATION_MAX_ENTRIES,
|
||||||
|
) -> None:
|
||||||
|
if creation_token is not _ATTESTATION_CREATION_TOKEN:
|
||||||
|
raise TypeError("P4 review attestation registries are host-owned")
|
||||||
|
if isinstance(default_ttl_seconds, bool) or not isinstance(default_ttl_seconds, (int, float)):
|
||||||
|
raise TypeError("P4 review attestation TTL is invalid")
|
||||||
|
if default_ttl_seconds <= 0 or default_ttl_seconds > 300:
|
||||||
|
raise ValueError("P4 review attestation TTL is invalid")
|
||||||
|
if isinstance(max_entries, bool) or not isinstance(max_entries, int) or max_entries < 1:
|
||||||
|
raise ValueError("P4 review attestation capacity is invalid")
|
||||||
|
self._clock = clock or time.monotonic
|
||||||
|
self._default_ttl_seconds = float(default_ttl_seconds)
|
||||||
|
self._max_entries = max_entries
|
||||||
|
self._lock = threading.RLock()
|
||||||
|
self._entries: dict[P4ReviewProducerAttestationHandle, _ProducerAttestationEntry] = {}
|
||||||
|
self._unloaded = False
|
||||||
|
|
||||||
|
def mint(
|
||||||
|
self,
|
||||||
|
request: object,
|
||||||
|
event: object,
|
||||||
|
p3_state: object,
|
||||||
|
candidate: Any,
|
||||||
|
*,
|
||||||
|
operation_id: Any,
|
||||||
|
ttl_seconds: float | None = None,
|
||||||
|
) -> P4ReviewProducerAttestationHandle | None:
|
||||||
|
"""Mint only after binding all live carriers and the normalized candidate."""
|
||||||
|
if request is None or event is None or p3_state is None:
|
||||||
|
return None
|
||||||
|
try:
|
||||||
|
operation_id = _required_id(operation_id)
|
||||||
|
normalized, code = normalize_review_candidate(
|
||||||
|
candidate,
|
||||||
|
now=datetime.min.replace(tzinfo=timezone.utc),
|
||||||
|
)
|
||||||
|
except Exception:
|
||||||
|
return None
|
||||||
|
if not operation_id or normalized is None or code:
|
||||||
|
return None
|
||||||
|
try:
|
||||||
|
ttl = self._default_ttl_seconds if ttl_seconds is None else float(ttl_seconds)
|
||||||
|
except (TypeError, ValueError):
|
||||||
|
return None
|
||||||
|
if ttl <= 0 or ttl > 300:
|
||||||
|
return None
|
||||||
|
proof = build_p3_review_proof(
|
||||||
|
p3_state,
|
||||||
|
person_id=normalized["person_id"],
|
||||||
|
identity_assurance=normalized["p3_proof"]["identity_assurance"],
|
||||||
|
scope_kind=normalized["scope_kind"],
|
||||||
|
scope_id=normalized["scope_id"],
|
||||||
|
)
|
||||||
|
if proof is None or proof != normalized["p3_proof"]:
|
||||||
|
return None
|
||||||
|
with self._lock:
|
||||||
|
self._cleanup_locked(self._clock())
|
||||||
|
if self._unloaded or len(self._entries) >= self._max_entries:
|
||||||
|
return None
|
||||||
|
handle = P4ReviewProducerAttestationHandle(_HANDLE_CREATION_TOKEN, self)
|
||||||
|
self._entries[handle] = _ProducerAttestationEntry(
|
||||||
|
request=request,
|
||||||
|
event=event,
|
||||||
|
p3_state=p3_state,
|
||||||
|
candidate_fingerprint=candidate_fingerprint(normalized),
|
||||||
|
candidate_id=normalized["candidate_id"],
|
||||||
|
event_id=normalized["event_id"],
|
||||||
|
person_id=normalized["person_id"],
|
||||||
|
scope_kind=normalized["scope_kind"],
|
||||||
|
scope_id=normalized["scope_id"],
|
||||||
|
operation_id=operation_id,
|
||||||
|
expires_at=self._clock() + ttl,
|
||||||
|
)
|
||||||
|
return handle
|
||||||
|
|
||||||
|
def consume(
|
||||||
|
self,
|
||||||
|
handle: object,
|
||||||
|
request: object,
|
||||||
|
event: object,
|
||||||
|
p3_state: object,
|
||||||
|
candidate: Any,
|
||||||
|
*,
|
||||||
|
operation_id: Any,
|
||||||
|
) -> dict[str, str] | None:
|
||||||
|
"""Consume once; wrong carriers, candidate, operation or expiry fail closed."""
|
||||||
|
if type(handle) is not P4ReviewProducerAttestationHandle:
|
||||||
|
return None
|
||||||
|
try:
|
||||||
|
if handle._registry is not self:
|
||||||
|
return None
|
||||||
|
except Exception:
|
||||||
|
return None
|
||||||
|
with self._lock:
|
||||||
|
entry = self._entries.pop(handle, None)
|
||||||
|
if entry is None or self._unloaded or self._clock() >= entry.expires_at:
|
||||||
|
return None
|
||||||
|
if request is not entry.request or event is not entry.event or p3_state is not entry.p3_state:
|
||||||
|
return None
|
||||||
|
try:
|
||||||
|
operation_id = _required_id(operation_id)
|
||||||
|
normalized, code = normalize_review_candidate(
|
||||||
|
candidate,
|
||||||
|
now=datetime.min.replace(tzinfo=timezone.utc),
|
||||||
|
)
|
||||||
|
except Exception:
|
||||||
|
return None
|
||||||
|
if (
|
||||||
|
not operation_id
|
||||||
|
or operation_id != entry.operation_id
|
||||||
|
or normalized is None
|
||||||
|
or code
|
||||||
|
or normalized["candidate_id"] != entry.candidate_id
|
||||||
|
or normalized["event_id"] != entry.event_id
|
||||||
|
or normalized["person_id"] != entry.person_id
|
||||||
|
or normalized["scope_kind"] != entry.scope_kind
|
||||||
|
or normalized["scope_id"] != entry.scope_id
|
||||||
|
or candidate_fingerprint(normalized) != entry.candidate_fingerprint
|
||||||
|
):
|
||||||
|
return None
|
||||||
|
return {
|
||||||
|
"candidate_fingerprint": entry.candidate_fingerprint,
|
||||||
|
"candidate_id": entry.candidate_id,
|
||||||
|
"event_id": entry.event_id,
|
||||||
|
"person_id": entry.person_id,
|
||||||
|
"scope_kind": entry.scope_kind,
|
||||||
|
"scope_id": entry.scope_id,
|
||||||
|
"operation_id": entry.operation_id,
|
||||||
|
}
|
||||||
|
|
||||||
|
def pending_count(self) -> int:
|
||||||
|
with self._lock:
|
||||||
|
self._cleanup_locked(self._clock())
|
||||||
|
return len(self._entries)
|
||||||
|
|
||||||
|
def unload(self) -> None:
|
||||||
|
with self._lock:
|
||||||
|
self._entries.clear()
|
||||||
|
self._unloaded = True
|
||||||
|
|
||||||
|
def _cleanup_locked(self, now: float) -> None:
|
||||||
|
for handle, entry in list(self._entries.items()):
|
||||||
|
if now >= entry.expires_at:
|
||||||
|
self._entries.pop(handle, None)
|
||||||
|
|
||||||
|
|
||||||
|
def _new_p4_review_attestation_registry(
|
||||||
|
*,
|
||||||
|
clock: Any | None = None,
|
||||||
|
default_ttl_seconds: float = P4_REVIEW_ATTESTATION_DEFAULT_TTL_SECONDS,
|
||||||
|
max_entries: int = P4_REVIEW_ATTESTATION_MAX_ENTRIES,
|
||||||
|
) -> P4ReviewAttestationRegistry:
|
||||||
|
"""Create the host-owned issuer used by the P3 observer."""
|
||||||
|
return P4ReviewAttestationRegistry(
|
||||||
|
_ATTESTATION_CREATION_TOKEN,
|
||||||
|
clock=clock,
|
||||||
|
default_ttl_seconds=default_ttl_seconds,
|
||||||
|
max_entries=max_entries,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def consume_p4_review_producer_attestation(
|
||||||
|
handle: Any,
|
||||||
|
request: object,
|
||||||
|
event: object,
|
||||||
|
p3_state: object,
|
||||||
|
candidate: Any,
|
||||||
|
*,
|
||||||
|
operation_id: Any,
|
||||||
|
) -> dict[str, str] | None:
|
||||||
|
if type(handle) is not P4ReviewProducerAttestationHandle:
|
||||||
|
return None
|
||||||
|
try:
|
||||||
|
registry = handle._registry
|
||||||
|
except Exception:
|
||||||
|
return None
|
||||||
|
if not isinstance(registry, P4ReviewAttestationRegistry):
|
||||||
|
return None
|
||||||
|
return registry.consume(
|
||||||
|
handle,
|
||||||
|
request,
|
||||||
|
event,
|
||||||
|
p3_state,
|
||||||
|
candidate,
|
||||||
|
operation_id=operation_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def _canonical(value: Any) -> str:
|
||||||
|
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
||||||
|
|
||||||
|
|
||||||
|
def _single_line_id(value: Any, *, limit: int = _MAX_ID_LENGTH) -> str:
|
||||||
|
"""Normalize one runtime/config ID without accepting a carrier-like value."""
|
||||||
|
if isinstance(value, bool) or not isinstance(value, (str, int)):
|
||||||
|
return ""
|
||||||
|
text = unicodedata.normalize("NFKC", str(value)).strip()
|
||||||
|
if not text or len(text) > limit or text.lower() in _OWNER_PLACEHOLDERS:
|
||||||
|
return ""
|
||||||
|
# IDs are deliberately one token: no newline, whitespace, NUL, or other
|
||||||
|
# control/format character may survive configuration parsing.
|
||||||
|
if any(character.isspace() or unicodedata.category(character).startswith("C") for character in text):
|
||||||
|
return ""
|
||||||
|
return text
|
||||||
|
|
||||||
|
|
||||||
|
def parse_owner_allowlist(value: Any) -> tuple[str, ...]:
|
||||||
|
"""Parse a config-only owner allowlist, accepting list/string separators.
|
||||||
|
|
||||||
|
The output is merely an allowlist. It is never a runtime credential: a
|
||||||
|
later gate must still obtain its actor from ``event.get_sender_id()``.
|
||||||
|
"""
|
||||||
|
raw_items: list[Any] = []
|
||||||
|
if isinstance(value, str):
|
||||||
|
raw_items.extend(piece for piece in re.split(r"[\s,,;;]+", value) if piece)
|
||||||
|
elif isinstance(value, (list, tuple, set, frozenset)):
|
||||||
|
for item in value:
|
||||||
|
if isinstance(item, str):
|
||||||
|
raw_items.extend(piece for piece in re.split(r"[\s,,;;]+", item) if piece)
|
||||||
|
else:
|
||||||
|
raw_items.append(item)
|
||||||
|
else:
|
||||||
|
raw_items.append(value)
|
||||||
|
result: list[str] = []
|
||||||
|
for raw in raw_items:
|
||||||
|
owner_id = _single_line_id(raw)
|
||||||
|
if owner_id and owner_id not in result:
|
||||||
|
result.append(owner_id)
|
||||||
|
return tuple(result)
|
||||||
|
|
||||||
|
|
||||||
|
def runtime_owner_identity(event: Any, configured_owner_ids: Any) -> dict[str, Any]:
|
||||||
|
"""Accept only a direct AstrBot runtime sender matching the config allowlist.
|
||||||
|
|
||||||
|
This intentionally does not inspect a dict, page field, request carrier,
|
||||||
|
model text, ``event.sender_id``, or ``event.user_id``. A test double is
|
||||||
|
valid only when it exposes a callable ``get_sender_id`` method.
|
||||||
|
"""
|
||||||
|
allowlist = parse_owner_allowlist(configured_owner_ids)
|
||||||
|
if not allowlist:
|
||||||
|
return {"accepted": False, "code": "p4_review_owner_allowlist_empty", "actor_id": ""}
|
||||||
|
if event is None:
|
||||||
|
return {"accepted": False, "code": "p4_review_owner_runtime_missing", "actor_id": ""}
|
||||||
|
try:
|
||||||
|
getter = getattr(event, "get_sender_id", None)
|
||||||
|
except Exception:
|
||||||
|
return {"accepted": False, "code": "p4_review_owner_runtime_unavailable", "actor_id": ""}
|
||||||
|
if not callable(getter):
|
||||||
|
return {"accepted": False, "code": "p4_review_owner_runtime_missing", "actor_id": ""}
|
||||||
|
try:
|
||||||
|
actor_id = _single_line_id(getter())
|
||||||
|
except Exception:
|
||||||
|
return {"accepted": False, "code": "p4_review_owner_runtime_unavailable", "actor_id": ""}
|
||||||
|
if not actor_id:
|
||||||
|
return {"accepted": False, "code": "p4_review_owner_runtime_invalid", "actor_id": ""}
|
||||||
|
if actor_id not in allowlist:
|
||||||
|
return {"accepted": False, "code": "p4_review_owner_not_allowed", "actor_id": ""}
|
||||||
|
return {
|
||||||
|
"accepted": True,
|
||||||
|
"code": "p4_review_owner_runtime_verified",
|
||||||
|
"actor_id": actor_id,
|
||||||
|
"allowlist_size": len(allowlist),
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def runtime_scope_identity(event: Any) -> dict[str, str]:
|
||||||
|
"""Read a scope only from direct AstrBot runtime methods.
|
||||||
|
|
||||||
|
Group IDs must never fall back to raw payload fields or unified message
|
||||||
|
origins. Unknown or exceptional scope identity is therefore rejected.
|
||||||
|
"""
|
||||||
|
if event is None:
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
try:
|
||||||
|
group_getter = getattr(event, "get_group_id", None)
|
||||||
|
except Exception:
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
if not callable(group_getter):
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
try:
|
||||||
|
group_id = _single_line_id(group_getter())
|
||||||
|
except Exception:
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
if not group_id:
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
try:
|
||||||
|
platform_getter = getattr(event, "get_platform_name", None)
|
||||||
|
except Exception:
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
if not callable(platform_getter):
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
try:
|
||||||
|
platform_id = _single_line_id(platform_getter())
|
||||||
|
except Exception:
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
if not platform_id:
|
||||||
|
return {"scope_kind": "", "scope_id": ""}
|
||||||
|
return {"scope_kind": "group", "scope_id": f"{platform_id}:{group_id}"}
|
||||||
|
|
||||||
|
|
||||||
|
def _timestamp(value: Any) -> tuple[str, datetime | None]:
|
||||||
|
if not isinstance(value, str) or not value or len(value) > 80 or "\x00" in value:
|
||||||
|
return "", None
|
||||||
|
text = value.strip()
|
||||||
|
if not text or any(character.isspace() for character in text[:-1]):
|
||||||
|
return "", None
|
||||||
|
try:
|
||||||
|
parsed = datetime.fromisoformat(text[:-1] + "+00:00" if text.endswith("Z") else text)
|
||||||
|
except (TypeError, ValueError):
|
||||||
|
return "", None
|
||||||
|
if parsed.tzinfo is None:
|
||||||
|
return "", None
|
||||||
|
utc = parsed.astimezone(timezone.utc)
|
||||||
|
return utc.isoformat(timespec="seconds").replace("+00:00", "Z"), utc
|
||||||
|
|
||||||
|
|
||||||
|
def _reason_code(value: Any) -> str:
|
||||||
|
if not isinstance(value, str):
|
||||||
|
return ""
|
||||||
|
code = value.strip().lower()
|
||||||
|
return code if len(code) <= _MAX_REASON_LENGTH and _REASON_RE.fullmatch(code) else ""
|
||||||
|
|
||||||
|
|
||||||
|
def _required_id(value: Any) -> str:
|
||||||
|
return _single_line_id(value, limit=_MAX_ID_LENGTH)
|
||||||
|
|
||||||
|
|
||||||
|
def build_p3_review_proof(
|
||||||
|
state: Any,
|
||||||
|
*,
|
||||||
|
person_id: Any,
|
||||||
|
identity_assurance: Any,
|
||||||
|
scope_kind: Any,
|
||||||
|
scope_id: Any,
|
||||||
|
) -> dict[str, Any] | None:
|
||||||
|
"""Project only a validated P3 final state into the review contract."""
|
||||||
|
if not isinstance(state, dict):
|
||||||
|
return None
|
||||||
|
if (
|
||||||
|
state.get("contract_name") != P3_CONTRACT_NAME
|
||||||
|
or state.get("contract_version") != P3_CONTRACT_VERSION
|
||||||
|
or state.get("contract_fingerprint") != p3_contract_fingerprint()
|
||||||
|
or state.get("phase") != "finalized"
|
||||||
|
or state.get("finalized") is not True
|
||||||
|
or state.get("completed_layers") != list(P3_LAYERS)
|
||||||
|
):
|
||||||
|
return None
|
||||||
|
normalized_person_id = _required_id(person_id)
|
||||||
|
assurance = str(identity_assurance or "").strip()
|
||||||
|
normalized_scope_kind = str(scope_kind or "").strip().lower()
|
||||||
|
normalized_scope_id = _required_id(scope_id)
|
||||||
|
security = state.get("security")
|
||||||
|
if (
|
||||||
|
not normalized_person_id
|
||||||
|
or assurance not in P4_REVIEW_ALLOWED_ASSURANCES
|
||||||
|
or normalized_scope_kind != "group"
|
||||||
|
or not normalized_scope_id
|
||||||
|
or state.get("scope") != normalized_scope_kind
|
||||||
|
or not isinstance(security, dict)
|
||||||
|
or security.get("status") not in P4_REVIEW_ALLOWED_SECURITY_STATUSES
|
||||||
|
or security.get("response_policy") not in P4_REVIEW_ALLOWED_POLICIES
|
||||||
|
):
|
||||||
|
return None
|
||||||
|
security_event_id = security.get("event_id")
|
||||||
|
if not isinstance(security_event_id, str) or len(security_event_id) > 180 or "\x00" in security_event_id:
|
||||||
|
return None
|
||||||
|
created_at = state.get("created_at")
|
||||||
|
normalized_created_at, _ = _timestamp(created_at)
|
||||||
|
if not normalized_created_at:
|
||||||
|
return None
|
||||||
|
return {
|
||||||
|
"contract_name": P3_CONTRACT_NAME,
|
||||||
|
"contract_version": P3_CONTRACT_VERSION,
|
||||||
|
"contract_fingerprint": p3_contract_fingerprint(),
|
||||||
|
"completed_layers": list(P3_LAYERS),
|
||||||
|
"phase": "finalized",
|
||||||
|
"finalized": True,
|
||||||
|
"security_status": security["status"],
|
||||||
|
"response_policy": security["response_policy"],
|
||||||
|
"security_event_id": security_event_id,
|
||||||
|
"person_id": normalized_person_id,
|
||||||
|
"identity_assurance": assurance,
|
||||||
|
"scope_kind": normalized_scope_kind,
|
||||||
|
"scope_id": normalized_scope_id,
|
||||||
|
"created_at": normalized_created_at,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def normalize_review_candidate(candidate: Any, *, now: datetime | None = None) -> tuple[dict[str, Any] | None, str]:
|
||||||
|
"""Validate the immutable, observer-produced review-candidate contract."""
|
||||||
|
if not isinstance(candidate, dict):
|
||||||
|
return None, "p4_review_candidate_invalid"
|
||||||
|
candidate_id = _required_id(candidate.get("candidate_id"))
|
||||||
|
event_id = _required_id(candidate.get("event_id"))
|
||||||
|
person_id = _required_id(candidate.get("person_id"))
|
||||||
|
scope_kind = str(candidate.get("scope_kind") or "").strip().lower()
|
||||||
|
scope_id = _required_id(candidate.get("scope_id"))
|
||||||
|
reason_code = _reason_code(candidate.get("reason_code"))
|
||||||
|
created_at, created_when = _timestamp(candidate.get("created_at"))
|
||||||
|
expires_at, expires_when = _timestamp(candidate.get("expires_at"))
|
||||||
|
proof = candidate.get("p3_proof")
|
||||||
|
if not all((candidate_id, event_id, person_id, scope_kind, scope_id, reason_code, created_at, expires_at)):
|
||||||
|
return None, "p4_review_candidate_missing_required_field"
|
||||||
|
if scope_kind != "group":
|
||||||
|
return None, "p4_review_candidate_scope_invalid"
|
||||||
|
if created_when is None or expires_when is None or expires_when <= created_when:
|
||||||
|
return None, "p4_review_candidate_time_invalid"
|
||||||
|
if not isinstance(proof, dict):
|
||||||
|
return None, "p4_review_candidate_p3_proof_invalid"
|
||||||
|
proof_created_at, proof_when = _timestamp(proof.get("created_at"))
|
||||||
|
proof_fingerprint = proof.get("contract_fingerprint")
|
||||||
|
proof_layers = proof.get("completed_layers")
|
||||||
|
proof_policy = proof.get("response_policy")
|
||||||
|
proof_event_id = proof.get("security_event_id")
|
||||||
|
proof_scope_kind = str(proof.get("scope_kind") or "").strip().lower()
|
||||||
|
proof_scope_id = _required_id(proof.get("scope_id"))
|
||||||
|
if (
|
||||||
|
proof.get("contract_name") != P3_CONTRACT_NAME
|
||||||
|
or proof.get("contract_version") != P3_CONTRACT_VERSION
|
||||||
|
or proof_fingerprint != p3_contract_fingerprint()
|
||||||
|
or proof_layers != list(P3_LAYERS)
|
||||||
|
or proof.get("phase") != "finalized"
|
||||||
|
or proof.get("finalized") is not True
|
||||||
|
or proof.get("security_status") not in P4_REVIEW_ALLOWED_SECURITY_STATUSES
|
||||||
|
or proof_policy not in P4_REVIEW_ALLOWED_POLICIES
|
||||||
|
or not isinstance(proof_event_id, str)
|
||||||
|
or len(proof_event_id) > 180
|
||||||
|
or "\x00" in proof_event_id
|
||||||
|
or proof.get("person_id") != person_id
|
||||||
|
or proof.get("identity_assurance") not in P4_REVIEW_ALLOWED_ASSURANCES
|
||||||
|
or proof_scope_kind != scope_kind
|
||||||
|
or proof_scope_id != scope_id
|
||||||
|
or proof_created_at != created_at
|
||||||
|
or proof_when is None
|
||||||
|
):
|
||||||
|
return None, "p4_review_candidate_p3_proof_invalid"
|
||||||
|
clock = now or datetime.now(timezone.utc)
|
||||||
|
if expires_when <= clock.astimezone(timezone.utc):
|
||||||
|
return None, "p4_review_candidate_expired"
|
||||||
|
return {
|
||||||
|
"candidate_id": candidate_id,
|
||||||
|
"event_id": event_id,
|
||||||
|
"person_id": person_id,
|
||||||
|
"scope_kind": scope_kind,
|
||||||
|
"scope_id": scope_id,
|
||||||
|
"created_at": created_at,
|
||||||
|
"expires_at": expires_at,
|
||||||
|
"reason_code": reason_code,
|
||||||
|
"p3_proof": {
|
||||||
|
"phase": "finalized",
|
||||||
|
"finalized": True,
|
||||||
|
"contract_name": P3_CONTRACT_NAME,
|
||||||
|
"contract_version": P3_CONTRACT_VERSION,
|
||||||
|
"contract_fingerprint": p3_contract_fingerprint(),
|
||||||
|
"completed_layers": list(P3_LAYERS),
|
||||||
|
"security_status": proof["security_status"],
|
||||||
|
"response_policy": proof_policy,
|
||||||
|
"security_event_id": proof_event_id,
|
||||||
|
"person_id": person_id,
|
||||||
|
"identity_assurance": proof["identity_assurance"],
|
||||||
|
"scope_kind": scope_kind,
|
||||||
|
"scope_id": scope_id,
|
||||||
|
"created_at": created_at,
|
||||||
|
},
|
||||||
|
}, ""
|
||||||
|
|
||||||
|
|
||||||
|
def candidate_fingerprint(candidate: dict[str, Any]) -> str:
|
||||||
|
return hashlib.sha256(_canonical(candidate).encode("utf-8")).hexdigest()
|
||||||
|
|
||||||
|
|
||||||
|
def decision_fingerprint(record: dict[str, Any], *, candidate_fp: str) -> str:
|
||||||
|
return hashlib.sha256(
|
||||||
|
_canonical(
|
||||||
|
{
|
||||||
|
"candidate_fingerprint": candidate_fp,
|
||||||
|
"candidate_id": record.get("candidate_id"),
|
||||||
|
"event_id": record.get("event_id"),
|
||||||
|
"person_id": record.get("person_id"),
|
||||||
|
"scope_kind": record.get("scope_kind"),
|
||||||
|
"scope_id": record.get("scope_id"),
|
||||||
|
"actor_id": record.get("actor_id"),
|
||||||
|
"decision": record.get("decision"),
|
||||||
|
"reason_code": record.get("reason_code"),
|
||||||
|
"occurred_at": record.get("occurred_at"),
|
||||||
|
"operation_id": record.get("operation_id"),
|
||||||
|
}
|
||||||
|
).encode("utf-8")
|
||||||
|
).hexdigest()
|
||||||
|
|
||||||
|
|
||||||
|
def ensure_review_container(root: dict[str, Any]) -> tuple[dict[str, Any] | None, str]:
|
||||||
|
"""Create an additive ``unified_person.p4_review`` container once.
|
||||||
|
|
||||||
|
Existing malformed containers fail closed rather than being replaced.
|
||||||
|
"""
|
||||||
|
if not isinstance(root, dict):
|
||||||
|
return None, "p4_review_corrupt"
|
||||||
|
container = root.get("p4_review")
|
||||||
|
if container is None:
|
||||||
|
container = {
|
||||||
|
"version": P4_REVIEW_VERSION,
|
||||||
|
"candidates": {},
|
||||||
|
"event_index": {},
|
||||||
|
"decisions": {},
|
||||||
|
}
|
||||||
|
root["p4_review"] = container
|
||||||
|
return container, ""
|
||||||
|
if not isinstance(container, dict):
|
||||||
|
return None, "p4_review_corrupt"
|
||||||
|
if container.get("version") != P4_REVIEW_VERSION:
|
||||||
|
return None, "p4_review_corrupt"
|
||||||
|
for key in ("candidates", "event_index", "decisions"):
|
||||||
|
if not isinstance(container.get(key), dict):
|
||||||
|
return None, "p4_review_corrupt"
|
||||||
|
return container, ""
|
||||||
|
|
||||||
|
|
||||||
|
def queue_candidate(
|
||||||
|
container: dict[str, Any],
|
||||||
|
candidate: dict[str, Any],
|
||||||
|
*,
|
||||||
|
operation_id: str,
|
||||||
|
recorded_at: str,
|
||||||
|
) -> tuple[dict[str, Any] | None, str]:
|
||||||
|
"""Append a candidate to only the separate review queue."""
|
||||||
|
candidates = container.get("candidates")
|
||||||
|
event_index = container.get("event_index")
|
||||||
|
if not isinstance(candidates, dict) or not isinstance(event_index, dict):
|
||||||
|
return None, "p4_review_corrupt"
|
||||||
|
fingerprint = candidate_fingerprint(candidate)
|
||||||
|
candidate_id = candidate["candidate_id"]
|
||||||
|
event_id = candidate["event_id"]
|
||||||
|
known = candidates.get(candidate_id)
|
||||||
|
if known is not None:
|
||||||
|
if not isinstance(known, dict) or known.get("candidate_fingerprint") != fingerprint:
|
||||||
|
return None, "p4_review_candidate_id_conflict"
|
||||||
|
indexed_known = event_index.get(candidate["event_id"])
|
||||||
|
if (
|
||||||
|
not isinstance(indexed_known, dict)
|
||||||
|
or indexed_known.get("candidate_id") != candidate_id
|
||||||
|
or indexed_known.get("candidate_fingerprint") != fingerprint
|
||||||
|
):
|
||||||
|
return None, "p4_review_candidate_integrity_error"
|
||||||
|
return deepcopy(known), "p4_review_candidate_duplicate"
|
||||||
|
indexed = event_index.get(event_id)
|
||||||
|
if indexed is not None:
|
||||||
|
if not isinstance(indexed, dict) or indexed.get("candidate_fingerprint") != fingerprint:
|
||||||
|
return None, "p4_review_event_id_conflict"
|
||||||
|
return None, "p4_review_candidate_id_conflict"
|
||||||
|
record = {
|
||||||
|
**deepcopy(candidate),
|
||||||
|
"candidate_fingerprint": fingerprint,
|
||||||
|
"recorded_at": recorded_at,
|
||||||
|
"operation_id": operation_id,
|
||||||
|
}
|
||||||
|
candidates[candidate_id] = record
|
||||||
|
event_index[event_id] = {"candidate_id": candidate_id, "candidate_fingerprint": fingerprint}
|
||||||
|
return deepcopy(record), "p4_review_candidate_recorded"
|
||||||
|
|
||||||
|
|
||||||
|
def queue_decision(
|
||||||
|
container: dict[str, Any],
|
||||||
|
*,
|
||||||
|
person_id: str,
|
||||||
|
candidate_id: str,
|
||||||
|
actor_id: str,
|
||||||
|
scope_kind: str,
|
||||||
|
scope_id: str,
|
||||||
|
decision: str,
|
||||||
|
reason_code: str,
|
||||||
|
operation_id: str,
|
||||||
|
occurred_at: str,
|
||||||
|
now: datetime | None = None,
|
||||||
|
) -> tuple[dict[str, Any] | None, str]:
|
||||||
|
"""Append an audited conclusion without any live P4 effect."""
|
||||||
|
candidates = container.get("candidates")
|
||||||
|
event_index = container.get("event_index")
|
||||||
|
decisions = container.get("decisions")
|
||||||
|
if not isinstance(candidates, dict) or not isinstance(event_index, dict) or not isinstance(decisions, dict):
|
||||||
|
return None, "p4_review_corrupt"
|
||||||
|
candidate = candidates.get(candidate_id)
|
||||||
|
if not isinstance(candidate, dict):
|
||||||
|
return None, "p4_review_candidate_not_found"
|
||||||
|
normalized, code = normalize_review_candidate(candidate, now=now)
|
||||||
|
if normalized is None:
|
||||||
|
return None, code
|
||||||
|
stored_fingerprint = candidate.get("candidate_fingerprint")
|
||||||
|
if stored_fingerprint != candidate_fingerprint(normalized):
|
||||||
|
return None, "p4_review_candidate_integrity_error"
|
||||||
|
indexed = event_index.get(normalized["event_id"])
|
||||||
|
if (
|
||||||
|
not isinstance(indexed, dict)
|
||||||
|
or indexed.get("candidate_id") != candidate_id
|
||||||
|
or indexed.get("candidate_fingerprint") != stored_fingerprint
|
||||||
|
):
|
||||||
|
return None, "p4_review_candidate_integrity_error"
|
||||||
|
if normalized["person_id"] != person_id:
|
||||||
|
return None, "p4_review_candidate_person_mismatch"
|
||||||
|
if normalized["scope_kind"] != scope_kind or normalized["scope_id"] != scope_id:
|
||||||
|
return None, "p4_review_candidate_scope_mismatch"
|
||||||
|
existing = decisions.get(candidate_id)
|
||||||
|
if existing is not None:
|
||||||
|
if not isinstance(existing, dict):
|
||||||
|
return None, "p4_review_corrupt"
|
||||||
|
expected_existing = {
|
||||||
|
"candidate_id": candidate_id,
|
||||||
|
"event_id": normalized["event_id"],
|
||||||
|
"person_id": normalized["person_id"],
|
||||||
|
"scope_kind": normalized["scope_kind"],
|
||||||
|
"scope_id": normalized["scope_id"],
|
||||||
|
"actor_id": existing.get("actor_id"),
|
||||||
|
"decision": existing.get("decision"),
|
||||||
|
"reason_code": existing.get("reason_code"),
|
||||||
|
"occurred_at": existing.get("occurred_at"),
|
||||||
|
"operation_id": existing.get("operation_id"),
|
||||||
|
}
|
||||||
|
if (
|
||||||
|
existing.get("candidate_fingerprint") != stored_fingerprint
|
||||||
|
or existing.get("event_id") != expected_existing["event_id"]
|
||||||
|
or existing.get("person_id") != expected_existing["person_id"]
|
||||||
|
or existing.get("scope_kind") != expected_existing["scope_kind"]
|
||||||
|
or existing.get("scope_id") != expected_existing["scope_id"]
|
||||||
|
or existing.get("decision_fingerprint") != decision_fingerprint(expected_existing, candidate_fp=stored_fingerprint)
|
||||||
|
):
|
||||||
|
return None, "p4_review_decision_integrity_error"
|
||||||
|
if existing.get("decision") != decision:
|
||||||
|
return None, "p4_review_decision_conflict"
|
||||||
|
if (
|
||||||
|
existing.get("actor_id") != actor_id
|
||||||
|
or existing.get("reason_code") != reason_code
|
||||||
|
or existing.get("scope_kind") != scope_kind
|
||||||
|
or existing.get("scope_id") != scope_id
|
||||||
|
):
|
||||||
|
return None, "p4_review_decision_conflict"
|
||||||
|
return deepcopy(existing), "p4_review_decision_duplicate"
|
||||||
|
record = {
|
||||||
|
"candidate_id": candidate_id,
|
||||||
|
"event_id": normalized["event_id"],
|
||||||
|
"person_id": person_id,
|
||||||
|
"scope_kind": scope_kind,
|
||||||
|
"scope_id": scope_id,
|
||||||
|
"actor_id": actor_id,
|
||||||
|
"decision": decision,
|
||||||
|
"reason_code": reason_code,
|
||||||
|
"occurred_at": occurred_at,
|
||||||
|
"operation_id": operation_id,
|
||||||
|
}
|
||||||
|
record["candidate_fingerprint"] = stored_fingerprint
|
||||||
|
record["decision_fingerprint"] = decision_fingerprint(record, candidate_fp=stored_fingerprint)
|
||||||
|
decisions[candidate_id] = record
|
||||||
|
return deepcopy(record), "p4_review_decision_recorded"
|
||||||
|
|
||||||
|
|
||||||
|
def validate_review_operation_replay(
|
||||||
|
container: Any,
|
||||||
|
*,
|
||||||
|
action: str,
|
||||||
|
result: dict[str, Any],
|
||||||
|
payload: dict[str, Any],
|
||||||
|
) -> str:
|
||||||
|
"""Re-check the ledger envelope before returning a cached operation result."""
|
||||||
|
if not result.get("ok"):
|
||||||
|
return ""
|
||||||
|
if not isinstance(container, dict):
|
||||||
|
return "p4_review_corrupt"
|
||||||
|
candidates = container.get("candidates")
|
||||||
|
event_index = container.get("event_index")
|
||||||
|
decisions = container.get("decisions")
|
||||||
|
if not isinstance(candidates, dict) or not isinstance(event_index, dict) or not isinstance(decisions, dict):
|
||||||
|
return "p4_review_corrupt"
|
||||||
|
candidate_id = payload.get("candidate_id")
|
||||||
|
if not isinstance(candidate_id, str) and isinstance(payload.get("candidate"), dict):
|
||||||
|
candidate_id = payload["candidate"].get("candidate_id")
|
||||||
|
if not isinstance(candidate_id, str):
|
||||||
|
return "p4_review_candidate_integrity_error"
|
||||||
|
stored_candidate = candidates.get(candidate_id)
|
||||||
|
if not isinstance(stored_candidate, dict):
|
||||||
|
return "p4_review_candidate_integrity_error"
|
||||||
|
normalized_candidate, candidate_code = normalize_review_candidate(
|
||||||
|
stored_candidate,
|
||||||
|
now=datetime.min.replace(tzinfo=timezone.utc),
|
||||||
|
)
|
||||||
|
stored_candidate_fp = stored_candidate.get("candidate_fingerprint")
|
||||||
|
if (
|
||||||
|
normalized_candidate is None
|
||||||
|
or candidate_code
|
||||||
|
or stored_candidate_fp != candidate_fingerprint(normalized_candidate)
|
||||||
|
or normalized_candidate["person_id"] != payload.get("person_id")
|
||||||
|
or not isinstance(event_index.get(normalized_candidate["event_id"]), dict)
|
||||||
|
or event_index[normalized_candidate["event_id"]].get("candidate_id") != candidate_id
|
||||||
|
or event_index[normalized_candidate["event_id"]].get("candidate_fingerprint") != stored_candidate_fp
|
||||||
|
):
|
||||||
|
return "p4_review_candidate_integrity_error"
|
||||||
|
if (
|
||||||
|
result.get("candidate_id") is not None
|
||||||
|
and result.get("candidate_id") != candidate_id
|
||||||
|
) or (
|
||||||
|
result.get("person_id") is not None
|
||||||
|
and result.get("person_id") != normalized_candidate["person_id"]
|
||||||
|
):
|
||||||
|
return "p4_review_candidate_integrity_error"
|
||||||
|
if action == "record_p4_manual_review_candidate":
|
||||||
|
if result.get("event_id") is not None and result.get("event_id") != normalized_candidate["event_id"]:
|
||||||
|
return "p4_review_candidate_integrity_error"
|
||||||
|
return ""
|
||||||
|
if action != "record_p4_manual_review_decision":
|
||||||
|
return ""
|
||||||
|
stored_decision = decisions.get(candidate_id)
|
||||||
|
if not isinstance(stored_decision, dict):
|
||||||
|
return "p4_review_decision_integrity_error"
|
||||||
|
expected_decision = {
|
||||||
|
"candidate_id": candidate_id,
|
||||||
|
"event_id": normalized_candidate["event_id"],
|
||||||
|
"person_id": normalized_candidate["person_id"],
|
||||||
|
"scope_kind": normalized_candidate["scope_kind"],
|
||||||
|
"scope_id": normalized_candidate["scope_id"],
|
||||||
|
"actor_id": stored_decision.get("actor_id"),
|
||||||
|
"decision": stored_decision.get("decision"),
|
||||||
|
"reason_code": stored_decision.get("reason_code"),
|
||||||
|
"occurred_at": stored_decision.get("occurred_at"),
|
||||||
|
"operation_id": stored_decision.get("operation_id"),
|
||||||
|
}
|
||||||
|
if (
|
||||||
|
stored_decision.get("candidate_fingerprint") != stored_candidate_fp
|
||||||
|
or any(stored_decision.get(key) != value for key, value in expected_decision.items() if key not in {"candidate_id", "actor_id", "decision", "reason_code", "occurred_at", "operation_id"})
|
||||||
|
or stored_decision.get("decision_fingerprint") != decision_fingerprint(expected_decision, candidate_fp=stored_candidate_fp)
|
||||||
|
or stored_decision.get("actor_id") != payload.get("actor_id")
|
||||||
|
or stored_decision.get("decision") != payload.get("decision")
|
||||||
|
or stored_decision.get("reason_code") != payload.get("reason_code")
|
||||||
|
or stored_decision.get("scope_kind") != payload.get("scope_kind")
|
||||||
|
or stored_decision.get("scope_id") != payload.get("scope_id")
|
||||||
|
):
|
||||||
|
return "p4_review_decision_integrity_error"
|
||||||
|
return ""
|
||||||
|
|
||||||
|
|
||||||
|
def normalize_decision_request(
|
||||||
|
*,
|
||||||
|
person_id: Any,
|
||||||
|
candidate_id: Any,
|
||||||
|
decision: Any,
|
||||||
|
reason_code: Any,
|
||||||
|
operation_id: Any,
|
||||||
|
) -> tuple[dict[str, str] | None, str]:
|
||||||
|
normalized_person_id = _required_id(person_id)
|
||||||
|
normalized_candidate_id = _required_id(candidate_id)
|
||||||
|
normalized_operation_id = _required_id(operation_id)
|
||||||
|
normalized_reason_code = _reason_code(reason_code)
|
||||||
|
normalized_decision = decision.strip().lower() if isinstance(decision, str) else ""
|
||||||
|
if not all((normalized_person_id, normalized_candidate_id, normalized_operation_id, normalized_reason_code)):
|
||||||
|
return None, "p4_review_decision_invalid"
|
||||||
|
if normalized_decision not in P4_REVIEW_ALLOWED_DECISIONS:
|
||||||
|
return None, "p4_review_decision_invalid"
|
||||||
|
return {
|
||||||
|
"person_id": normalized_person_id,
|
||||||
|
"candidate_id": normalized_candidate_id,
|
||||||
|
"decision": normalized_decision,
|
||||||
|
"reason_code": normalized_reason_code,
|
||||||
|
"operation_id": normalized_operation_id,
|
||||||
|
}, ""
|
||||||
586
tests/test_p4_manual_review.py
普通文件
586
tests/test_p4_manual_review.py
普通文件
|
|
@ -0,0 +1,586 @@
|
||||||
|
# -*- coding: utf-8 -*-
|
||||||
|
"""Pure P4 manual-review boundary tests: no P4 live effect is exercised."""
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from copy import deepcopy
|
||||||
|
from datetime import datetime, timedelta, timezone
|
||||||
|
import importlib
|
||||||
|
from pathlib import Path
|
||||||
|
import sys
|
||||||
|
import types
|
||||||
|
import unittest
|
||||||
|
|
||||||
|
|
||||||
|
ROOT = Path(__file__).resolve().parents[1]
|
||||||
|
if str(ROOT) not in sys.path:
|
||||||
|
sys.path.insert(0, str(ROOT))
|
||||||
|
|
||||||
|
from p4_manual_review import (
|
||||||
|
P3_CONTRACT_NAME,
|
||||||
|
P3_CONTRACT_VERSION,
|
||||||
|
P3_LAYERS,
|
||||||
|
_new_p4_review_attestation_registry,
|
||||||
|
p3_contract_fingerprint,
|
||||||
|
parse_owner_allowlist,
|
||||||
|
runtime_owner_identity,
|
||||||
|
)
|
||||||
|
from unified_person_contract import empty_unified_person_store
|
||||||
|
from unified_person_registry import UnifiedPersonRegistry
|
||||||
|
|
||||||
|
|
||||||
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||||
|
import _host_stub # noqa: E402
|
||||||
|
|
||||||
|
_host_stub.install()
|
||||||
|
_PACKAGE = "_p4_manual_review_core_store_companion"
|
||||||
|
if _PACKAGE not in sys.modules:
|
||||||
|
package = types.ModuleType(_PACKAGE)
|
||||||
|
package.__path__ = [str(ROOT)]
|
||||||
|
sys.modules[_PACKAGE] = package
|
||||||
|
core_store_module = importlib.import_module(f"{_PACKAGE}.core_store")
|
||||||
|
core_review_module = importlib.import_module(f"{_PACKAGE}.p4_manual_review")
|
||||||
|
context_module = importlib.import_module(f"{_PACKAGE}.context_orchestration")
|
||||||
|
|
||||||
|
|
||||||
|
def identity(subject_id: str) -> dict[str, str]:
|
||||||
|
return {
|
||||||
|
"companion_instance_id": "companion-a",
|
||||||
|
"bot_account_id": "bot-a",
|
||||||
|
"adapter_instance_id": "telegram-main",
|
||||||
|
"subject_namespace": "telegram.user",
|
||||||
|
"platform_subject_id": subject_id,
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def timestamp(value: datetime) -> str:
|
||||||
|
return value.astimezone(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
|
||||||
|
|
||||||
|
|
||||||
|
def candidate(
|
||||||
|
person_id: str,
|
||||||
|
*,
|
||||||
|
token: str = "one",
|
||||||
|
assurance: str = "verified",
|
||||||
|
created_offset: timedelta = timedelta(),
|
||||||
|
expires_in: timedelta = timedelta(hours=1),
|
||||||
|
scope_id: str = "aiocqhttp:group-1",
|
||||||
|
) -> dict:
|
||||||
|
created = (datetime.now(timezone.utc) + created_offset).replace(microsecond=0)
|
||||||
|
created_at = timestamp(created)
|
||||||
|
return {
|
||||||
|
"candidate_id": f"candidate-{token}",
|
||||||
|
"event_id": f"event-{token}",
|
||||||
|
"person_id": person_id,
|
||||||
|
"scope_kind": "group",
|
||||||
|
"scope_id": scope_id,
|
||||||
|
"created_at": created_at,
|
||||||
|
"expires_at": timestamp(created + expires_in),
|
||||||
|
"reason_code": "p3_finalized_observed",
|
||||||
|
"p3_proof": {
|
||||||
|
"contract_name": P3_CONTRACT_NAME,
|
||||||
|
"contract_version": P3_CONTRACT_VERSION,
|
||||||
|
"contract_fingerprint": p3_contract_fingerprint(),
|
||||||
|
"completed_layers": list(P3_LAYERS),
|
||||||
|
"phase": "finalized",
|
||||||
|
"finalized": True,
|
||||||
|
"security_status": "allowed",
|
||||||
|
"response_policy": "inherit",
|
||||||
|
"security_event_id": "",
|
||||||
|
"person_id": person_id,
|
||||||
|
"identity_assurance": assurance,
|
||||||
|
"scope_kind": "group",
|
||||||
|
"scope_id": scope_id,
|
||||||
|
"created_at": created_at,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
class _RuntimeEvent:
|
||||||
|
def __init__(self, sender_id: object = "owner-a", *, raises: bool = False, group_id: str = "group-1", platform: str = "aiocqhttp") -> None:
|
||||||
|
self._sender_id = sender_id
|
||||||
|
self._raises = raises
|
||||||
|
self._group_id = group_id
|
||||||
|
self._platform = platform
|
||||||
|
# These forged event fields must never be read by the owner gate.
|
||||||
|
self.sender_id = "forged-field-owner"
|
||||||
|
self.user_id = "forged-field-owner"
|
||||||
|
|
||||||
|
def get_group_id(self):
|
||||||
|
return self._group_id
|
||||||
|
|
||||||
|
def get_platform_name(self):
|
||||||
|
return self._platform
|
||||||
|
|
||||||
|
def get_sender_id(self):
|
||||||
|
if self._raises:
|
||||||
|
raise RuntimeError("runtime unavailable")
|
||||||
|
return self._sender_id
|
||||||
|
|
||||||
|
|
||||||
|
def _make_candidate_attestation(raw: dict, operation_id: str, review_module=None):
|
||||||
|
state = _build_p3_state(raw)
|
||||||
|
request = object()
|
||||||
|
event = _RuntimeEvent("sender-42")
|
||||||
|
registry = (review_module or sys.modules["p4_manual_review"])._new_p4_review_attestation_registry()
|
||||||
|
handle = registry.mint(request, event, state, raw, operation_id=operation_id)
|
||||||
|
return handle, request, event, state
|
||||||
|
|
||||||
|
|
||||||
|
def _build_p3_state(raw: dict) -> dict:
|
||||||
|
state = context_module.new_context_state(scope="group", created_at=raw["created_at"])
|
||||||
|
context_module.update_security(state, status=raw["p3_proof"]["security_status"], response_policy=raw["p3_proof"]["response_policy"])
|
||||||
|
for layer in context_module.LAYERS:
|
||||||
|
context_module.complete_layer(state, layer)
|
||||||
|
context_module.finalize_state(state)
|
||||||
|
return state
|
||||||
|
|
||||||
|
|
||||||
|
class _CoreStoreHost(core_store_module.CoreStoreMixin):
|
||||||
|
def __init__(self, data: dict) -> None:
|
||||||
|
self.data = data
|
||||||
|
self.save_calls = 0
|
||||||
|
self.enable_p4_manual_review = True
|
||||||
|
|
||||||
|
def _schedule_data_save(self) -> None:
|
||||||
|
self.save_calls += 1
|
||||||
|
|
||||||
|
|
||||||
|
class P4ManualReviewOwnerGateTests(unittest.TestCase):
|
||||||
|
def test_config_allowlist_parses_only_safe_single_line_ids(self) -> None:
|
||||||
|
self.assertEqual(
|
||||||
|
("owner-a", "owner-b", "owner-c", "123"),
|
||||||
|
parse_owner_allowlist([" owner-a, owner-b\nowner-c ", 123, "owner-a"]),
|
||||||
|
)
|
||||||
|
self.assertEqual((), parse_owner_allowlist({"owner": "not-a-list"}))
|
||||||
|
self.assertEqual((), parse_owner_allowlist(["owner-a\x00evil", "\n"]))
|
||||||
|
|
||||||
|
def test_runtime_owner_requires_direct_get_sender_id_and_allowlist_match(self) -> None:
|
||||||
|
accepted = runtime_owner_identity(_RuntimeEvent("owner-a"), "owner-a, owner-b")
|
||||||
|
self.assertTrue(accepted["accepted"])
|
||||||
|
self.assertEqual("owner-a", accepted["actor_id"])
|
||||||
|
|
||||||
|
cases = [
|
||||||
|
({"get_sender_id": lambda: "owner-a", "sender_id": "owner-a"}, "p4_review_owner_runtime_missing"),
|
||||||
|
(_RuntimeEvent("intruder"), "p4_review_owner_not_allowed"),
|
||||||
|
(_RuntimeEvent("owner-a\nforged"), "p4_review_owner_runtime_invalid"),
|
||||||
|
(_RuntimeEvent(raises=True), "p4_review_owner_runtime_unavailable"),
|
||||||
|
(None, "p4_review_owner_runtime_missing"),
|
||||||
|
]
|
||||||
|
for event, code in cases:
|
||||||
|
with self.subTest(code=code):
|
||||||
|
result = runtime_owner_identity(event, ["owner-a"])
|
||||||
|
self.assertFalse(result["accepted"])
|
||||||
|
self.assertEqual(code, result["code"])
|
||||||
|
|
||||||
|
|
||||||
|
class P4ManualReviewAttestationTests(unittest.TestCase):
|
||||||
|
def _mint(self, *, registry=None, operation_id="attestation-op"):
|
||||||
|
raw = candidate("person-attestation", token=operation_id)
|
||||||
|
state = _build_p3_state(raw)
|
||||||
|
request = object()
|
||||||
|
event = _RuntimeEvent("sender-42")
|
||||||
|
registry = registry or _new_p4_review_attestation_registry()
|
||||||
|
handle = registry.mint(request, event, state, raw, operation_id=operation_id)
|
||||||
|
self.assertIsNotNone(handle)
|
||||||
|
return registry, handle, request, event, state, raw
|
||||||
|
|
||||||
|
def test_attestation_binds_exact_carriers_candidate_and_operation_once(self) -> None:
|
||||||
|
registry, handle, request, event, state, raw = self._mint()
|
||||||
|
snapshot = registry.consume(handle, request, event, state, raw, operation_id="attestation-op")
|
||||||
|
self.assertIsInstance(snapshot, dict)
|
||||||
|
self.assertEqual("attestation-op", snapshot["operation_id"])
|
||||||
|
self.assertIsNone(registry.consume(handle, request, event, state, raw, operation_id="attestation-op"))
|
||||||
|
|
||||||
|
def test_wrong_carrier_or_candidate_consumes_handle_and_cannot_retry(self) -> None:
|
||||||
|
registry, handle, request, event, state, raw = self._mint()
|
||||||
|
wrong_candidate = deepcopy(raw)
|
||||||
|
wrong_candidate["reason_code"] = "different_reason"
|
||||||
|
self.assertIsNone(
|
||||||
|
registry.consume(handle, request, event, state, wrong_candidate, operation_id="attestation-op")
|
||||||
|
)
|
||||||
|
self.assertIsNone(registry.consume(handle, request, event, state, raw, operation_id="attestation-op"))
|
||||||
|
|
||||||
|
def test_fake_handle_and_expiry_fail_closed(self) -> None:
|
||||||
|
registry, handle, request, event, state, raw = self._mint()
|
||||||
|
self.assertIsNone(registry.consume(object(), request, event, state, raw, operation_id="attestation-op"))
|
||||||
|
now = [0.0]
|
||||||
|
expiring = _new_p4_review_attestation_registry(clock=lambda: now[0], default_ttl_seconds=1.0)
|
||||||
|
expiring_handle, expiring_request, expiring_event, expiring_state, expiring_raw = self._mint(
|
||||||
|
registry=expiring, operation_id="expiring-op"
|
||||||
|
)[1:]
|
||||||
|
now[0] = 2.0
|
||||||
|
self.assertIsNone(
|
||||||
|
expiring.consume(
|
||||||
|
expiring_handle,
|
||||||
|
expiring_request,
|
||||||
|
expiring_event,
|
||||||
|
expiring_state,
|
||||||
|
expiring_raw,
|
||||||
|
operation_id="expiring-op",
|
||||||
|
)
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
class P4ManualReviewRegistryTests(unittest.TestCase):
|
||||||
|
def setUp(self) -> None:
|
||||||
|
self.store = {"unified_person": empty_unified_person_store()}
|
||||||
|
self.registry = UnifiedPersonRegistry(self.store)
|
||||||
|
|
||||||
|
def _person(self, subject: str = "reviewer-target", *, assurance: str = "verified") -> str:
|
||||||
|
result = self.registry.upsert_observed_identity(identity(subject), operation_id=f"observe-{subject}")
|
||||||
|
self.assertTrue(result["ok"])
|
||||||
|
person_id = result["person_id"]
|
||||||
|
self.store["unified_person"]["profiles"][person_id]["identity_assurance"] = assurance
|
||||||
|
return person_id
|
||||||
|
|
||||||
|
def _queue(self, person_id: str, token: str = "one", *, operation_id: str | None = None, **kwargs) -> dict:
|
||||||
|
raw = candidate(person_id, token=token, **kwargs)
|
||||||
|
return self._record_candidate(person_id, raw, operation_id=operation_id or f"queue-{token}")
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def _p3_state(raw: dict) -> dict:
|
||||||
|
state = context_module.new_context_state(scope="group", created_at=raw["created_at"])
|
||||||
|
context_module.update_security(state, status=raw["p3_proof"]["security_status"], response_policy=raw["p3_proof"]["response_policy"])
|
||||||
|
for layer in context_module.LAYERS:
|
||||||
|
context_module.complete_layer(state, layer)
|
||||||
|
context_module.finalize_state(state)
|
||||||
|
return state
|
||||||
|
|
||||||
|
def _record_candidate(self, person_id: str, raw: dict, *, operation_id: str) -> dict:
|
||||||
|
attestation, request, event, state = self._mint(raw, operation_id=operation_id)
|
||||||
|
return self.registry.record_p4_manual_review_candidate(
|
||||||
|
person_id,
|
||||||
|
raw,
|
||||||
|
operation_id=operation_id,
|
||||||
|
producer_attestation=attestation,
|
||||||
|
producer_request=request,
|
||||||
|
producer_event=event,
|
||||||
|
producer_state=state,
|
||||||
|
)
|
||||||
|
|
||||||
|
def _mint(self, raw: dict, *, operation_id: str):
|
||||||
|
request = object()
|
||||||
|
event = _RuntimeEvent("sender-42")
|
||||||
|
state = self._p3_state(raw)
|
||||||
|
registry = _new_p4_review_attestation_registry()
|
||||||
|
attestation = registry.mint(request, event, state, raw, operation_id=operation_id)
|
||||||
|
return attestation, request, event, state
|
||||||
|
|
||||||
|
def test_candidate_queue_is_additive_and_ignores_forged_self_authorization(self) -> None:
|
||||||
|
person_id = self._person()
|
||||||
|
profile_before = deepcopy(self.store["unified_person"]["profiles"][person_id])
|
||||||
|
raw = candidate(person_id)
|
||||||
|
raw.update({"authorized": True, "approved": True, "owner": "forged-owner"})
|
||||||
|
result = self._record_candidate(person_id, raw, operation_id="queue-one")
|
||||||
|
|
||||||
|
self.assertTrue(result["ok"])
|
||||||
|
self.assertEqual("p4_review_candidate_recorded", result["code"])
|
||||||
|
self.assertFalse(result["live_effect_permitted"])
|
||||||
|
self.assertFalse(result["effect_applied"])
|
||||||
|
self.assertEqual(profile_before, self.store["unified_person"]["profiles"][person_id])
|
||||||
|
root = self.store["unified_person"]
|
||||||
|
self.assertIn("p4_review", root)
|
||||||
|
self.assertNotIn("p4_shadow", root)
|
||||||
|
self.assertNotIn("p4_effect", root)
|
||||||
|
saved = root["p4_review"]["candidates"]["candidate-one"]
|
||||||
|
self.assertNotIn("authorized", saved)
|
||||||
|
self.assertNotIn("approved", saved)
|
||||||
|
self.assertNotIn("owner", saved)
|
||||||
|
self.assertEqual("p4_manual_review_candidate_recorded", self.registry.audit_events()[-1]["action"])
|
||||||
|
|
||||||
|
def test_candidate_requires_observer_token_and_exact_p3_policy(self) -> None:
|
||||||
|
person_id = self._person("producer-boundary")
|
||||||
|
raw = candidate(person_id, token="producer-boundary")
|
||||||
|
denied = self.registry.record_p4_manual_review_candidate(
|
||||||
|
person_id, raw, operation_id="producer-missing"
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_producer_unavailable", denied["code"])
|
||||||
|
original = candidate(person_id, token="producer-forged-policy")
|
||||||
|
attestation, request, event, state = self._mint(original, operation_id="producer-forged-policy")
|
||||||
|
forged = deepcopy(original)
|
||||||
|
forged["p3_proof"]["response_policy"] = "forged-policy"
|
||||||
|
invalid = self.registry.record_p4_manual_review_candidate(
|
||||||
|
person_id,
|
||||||
|
forged,
|
||||||
|
operation_id="producer-forged-policy",
|
||||||
|
producer_attestation=attestation,
|
||||||
|
producer_request=request,
|
||||||
|
producer_event=event,
|
||||||
|
producer_state=state,
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_candidate_p3_proof_invalid", invalid["code"])
|
||||||
|
|
||||||
|
def test_missing_unknown_inactive_low_assurance_cross_person_and_expired_candidates_fail_closed(self) -> None:
|
||||||
|
missing = self.registry.record_p4_manual_review_candidate(
|
||||||
|
"person-missing", {"candidate_id": "only"}, operation_id="missing-fields"
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_candidate_missing_required_field", missing["code"])
|
||||||
|
self.assertNotIn("p4_review", self.store["unified_person"])
|
||||||
|
|
||||||
|
person_id = self._person("unknown-check")
|
||||||
|
unknown = self._record_candidate("person-other", candidate("person-other", token="unknown"), operation_id="unknown")
|
||||||
|
self.assertEqual("person_not_found", unknown["code"])
|
||||||
|
|
||||||
|
cross_person = self._record_candidate(person_id, candidate("person-other", token="cross"), operation_id="cross")
|
||||||
|
self.assertEqual("p4_review_candidate_person_mismatch", cross_person["code"])
|
||||||
|
|
||||||
|
self.store["unified_person"]["profiles"][person_id]["profile_status"] = "suspended"
|
||||||
|
inactive = self._queue(person_id, "inactive")
|
||||||
|
self.assertEqual("person_not_active", inactive["code"])
|
||||||
|
self.store["unified_person"]["profiles"][person_id]["profile_status"] = "active"
|
||||||
|
|
||||||
|
self.store["unified_person"]["profiles"][person_id]["identity_assurance"] = "observed"
|
||||||
|
low_assurance = self._queue(person_id, "low")
|
||||||
|
self.assertEqual("p4_review_person_assurance_insufficient", low_assurance["code"])
|
||||||
|
self.store["unified_person"]["profiles"][person_id]["identity_assurance"] = "verified"
|
||||||
|
|
||||||
|
expired = self._queue(
|
||||||
|
person_id,
|
||||||
|
"expired",
|
||||||
|
created_offset=timedelta(hours=-2),
|
||||||
|
expires_in=timedelta(hours=1),
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_candidate_expired", expired["code"])
|
||||||
|
self.assertNotIn("p4_review", self.store["unified_person"])
|
||||||
|
|
||||||
|
def test_candidate_idempotence_duplicate_and_conflicts_do_not_overwrite(self) -> None:
|
||||||
|
person_id = self._person("idempotence")
|
||||||
|
raw = candidate(person_id, token="idempotence")
|
||||||
|
first = self._record_candidate(person_id, raw, operation_id="candidate-op")
|
||||||
|
self.assertTrue(first["ok"])
|
||||||
|
snapshot = deepcopy(self.store)
|
||||||
|
|
||||||
|
repeated = self._record_candidate(person_id, deepcopy(raw), operation_id="candidate-op")
|
||||||
|
self.assertTrue(repeated["ok"])
|
||||||
|
self.assertTrue(repeated["idempotent"])
|
||||||
|
self.assertEqual(snapshot, self.store)
|
||||||
|
|
||||||
|
duplicate = self._record_candidate(person_id, deepcopy(raw), operation_id="candidate-duplicate-op")
|
||||||
|
self.assertTrue(duplicate["ok"])
|
||||||
|
self.assertTrue(duplicate["candidate_duplicate"])
|
||||||
|
self.assertFalse(duplicate["changed"])
|
||||||
|
conflict_snapshot = deepcopy(self.store)
|
||||||
|
|
||||||
|
conflicting_candidate = deepcopy(raw)
|
||||||
|
conflicting_candidate["reason_code"] = "different_reason"
|
||||||
|
conflict = self._record_candidate(person_id, conflicting_candidate, operation_id="candidate-conflict-op")
|
||||||
|
self.assertEqual("p4_review_candidate_id_conflict", conflict["code"])
|
||||||
|
self.assertEqual(conflict_snapshot, self.store)
|
||||||
|
|
||||||
|
operation_conflict = self._queue(person_id, "other", operation_id="candidate-op")
|
||||||
|
self.assertEqual("operation_id_conflict", operation_conflict["code"])
|
||||||
|
self.assertEqual(conflict_snapshot, self.store)
|
||||||
|
|
||||||
|
def test_decision_requires_runtime_owner_and_is_audit_only(self) -> None:
|
||||||
|
person_id = self._person("decision")
|
||||||
|
self.assertTrue(self._queue(person_id, "decision")["ok"])
|
||||||
|
profile_before = deepcopy(self.store["unified_person"]["profiles"][person_id])
|
||||||
|
|
||||||
|
forged = self.registry.record_p4_manual_review_decision(
|
||||||
|
{"sender_id": "owner-a", "authorized": True}, ["owner-a"], person_id, "candidate-decision",
|
||||||
|
operation_id="decision-forged", decision="approve", reason_code="manual_check",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_owner_runtime_missing", forged["code"])
|
||||||
|
|
||||||
|
approved = self.registry.record_p4_manual_review_decision(
|
||||||
|
_RuntimeEvent("owner-a"), ["owner-a"], person_id, "candidate-decision",
|
||||||
|
operation_id="decision-approve", decision="approve", reason_code="manual_check",
|
||||||
|
)
|
||||||
|
self.assertTrue(approved["ok"])
|
||||||
|
self.assertEqual("owner-a", approved["actor_id"])
|
||||||
|
self.assertFalse(approved["live_effect_permitted"])
|
||||||
|
self.assertEqual(profile_before, self.store["unified_person"]["profiles"][person_id])
|
||||||
|
root = self.store["unified_person"]
|
||||||
|
self.assertNotIn("p4_shadow", root)
|
||||||
|
self.assertNotIn("p4_effect", root)
|
||||||
|
decision = root["p4_review"]["decisions"]["candidate-decision"]
|
||||||
|
self.assertEqual("approve", decision["decision"])
|
||||||
|
self.assertEqual("owner-a", decision["actor_id"])
|
||||||
|
audit = self.registry.audit_events()[-1]
|
||||||
|
self.assertEqual("p4_manual_review_decision_recorded", audit["action"])
|
||||||
|
self.assertEqual("owner-a", audit["actor_id"])
|
||||||
|
|
||||||
|
def test_decision_idempotence_duplicate_and_opposite_decision_conflict(self) -> None:
|
||||||
|
person_id = self._person("decision-idempotence")
|
||||||
|
self.assertTrue(self._queue(person_id, "decision-idempotence")["ok"])
|
||||||
|
event = _RuntimeEvent("owner-a")
|
||||||
|
first = self.registry.record_p4_manual_review_decision(
|
||||||
|
event, "owner-a", person_id, "candidate-decision-idempotence",
|
||||||
|
operation_id="decision-op", decision="reject", reason_code="manual_reject",
|
||||||
|
)
|
||||||
|
self.assertTrue(first["ok"])
|
||||||
|
snapshot = deepcopy(self.store)
|
||||||
|
repeated = self.registry.record_p4_manual_review_decision(
|
||||||
|
event, "owner-a", person_id, "candidate-decision-idempotence",
|
||||||
|
operation_id="decision-op", decision="reject", reason_code="manual_reject",
|
||||||
|
)
|
||||||
|
self.assertTrue(repeated["idempotent"])
|
||||||
|
self.assertEqual(snapshot, self.store)
|
||||||
|
|
||||||
|
duplicate = self.registry.record_p4_manual_review_decision(
|
||||||
|
event, "owner-a", person_id, "candidate-decision-idempotence",
|
||||||
|
operation_id="decision-duplicate-op", decision="reject", reason_code="manual_reject",
|
||||||
|
)
|
||||||
|
self.assertTrue(duplicate["ok"])
|
||||||
|
self.assertTrue(duplicate["decision_duplicate"])
|
||||||
|
conflict_snapshot = deepcopy(self.store)
|
||||||
|
|
||||||
|
opposite = self.registry.record_p4_manual_review_decision(
|
||||||
|
event, "owner-a", person_id, "candidate-decision-idempotence",
|
||||||
|
operation_id="decision-opposite-op", decision="approve", reason_code="manual_approve",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_decision_conflict", opposite["code"])
|
||||||
|
self.assertEqual(conflict_snapshot, self.store)
|
||||||
|
|
||||||
|
operation_conflict = self.registry.record_p4_manual_review_decision(
|
||||||
|
event, "owner-a", person_id, "candidate-decision-idempotence",
|
||||||
|
operation_id="decision-op", decision="approve", reason_code="manual_approve",
|
||||||
|
)
|
||||||
|
self.assertEqual("operation_id_conflict", operation_conflict["code"])
|
||||||
|
self.assertEqual(conflict_snapshot, self.store)
|
||||||
|
|
||||||
|
other_group = _RuntimeEvent("owner-a", group_id="group-2")
|
||||||
|
cross_group = self.registry.record_p4_manual_review_decision(
|
||||||
|
other_group,
|
||||||
|
"owner-a",
|
||||||
|
person_id,
|
||||||
|
"candidate-decision-idempotence",
|
||||||
|
operation_id="decision-cross-group",
|
||||||
|
decision="reject",
|
||||||
|
reason_code="manual_reject",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_candidate_scope_mismatch", cross_group["code"])
|
||||||
|
same_operation_cross_group = self.registry.record_p4_manual_review_decision(
|
||||||
|
other_group,
|
||||||
|
"owner-a",
|
||||||
|
person_id,
|
||||||
|
"candidate-decision-idempotence",
|
||||||
|
operation_id="decision-op",
|
||||||
|
decision="reject",
|
||||||
|
reason_code="manual_reject",
|
||||||
|
)
|
||||||
|
self.assertEqual("operation_id_conflict", same_operation_cross_group["code"])
|
||||||
|
|
||||||
|
def test_candidate_and_decision_integrity_tampering_fails_closed(self) -> None:
|
||||||
|
person_id = self._person("integrity")
|
||||||
|
self.assertTrue(self._queue(person_id, "integrity")["ok"])
|
||||||
|
root = self.store["unified_person"]
|
||||||
|
root["p4_review"]["candidates"]["candidate-integrity"]["event_id"] = "event-tampered"
|
||||||
|
same_operation_candidate = self._record_candidate(
|
||||||
|
person_id,
|
||||||
|
candidate(person_id, token="integrity"),
|
||||||
|
operation_id="queue-integrity",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_candidate_integrity_error", same_operation_candidate["code"])
|
||||||
|
tampered_candidate = self.registry.record_p4_manual_review_decision(
|
||||||
|
_RuntimeEvent("owner-a"),
|
||||||
|
"owner-a",
|
||||||
|
person_id,
|
||||||
|
"candidate-integrity",
|
||||||
|
operation_id="integrity-decision",
|
||||||
|
decision="approve",
|
||||||
|
reason_code="manual_check",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_candidate_integrity_error", tampered_candidate["code"])
|
||||||
|
|
||||||
|
person_id = self._person("decision-integrity")
|
||||||
|
self.assertTrue(self._queue(person_id, "decision-integrity")["ok"])
|
||||||
|
approved = self.registry.record_p4_manual_review_decision(
|
||||||
|
_RuntimeEvent("owner-a"),
|
||||||
|
"owner-a",
|
||||||
|
person_id,
|
||||||
|
"candidate-decision-integrity",
|
||||||
|
operation_id="integrity-decision-ok",
|
||||||
|
decision="approve",
|
||||||
|
reason_code="manual_check",
|
||||||
|
)
|
||||||
|
self.assertTrue(approved["ok"])
|
||||||
|
root = self.store["unified_person"]
|
||||||
|
root["p4_review"]["decisions"]["candidate-decision-integrity"]["event_id"] = "event-tampered"
|
||||||
|
same_operation_decision = self.registry.record_p4_manual_review_decision(
|
||||||
|
_RuntimeEvent("owner-a"),
|
||||||
|
"owner-a",
|
||||||
|
person_id,
|
||||||
|
"candidate-decision-integrity",
|
||||||
|
operation_id="integrity-decision-ok",
|
||||||
|
decision="approve",
|
||||||
|
reason_code="manual_check",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_decision_integrity_error", same_operation_decision["code"])
|
||||||
|
tampered_decision = self.registry.record_p4_manual_review_decision(
|
||||||
|
_RuntimeEvent("owner-a"),
|
||||||
|
"owner-a",
|
||||||
|
person_id,
|
||||||
|
"candidate-decision-integrity",
|
||||||
|
operation_id="integrity-decision-replay",
|
||||||
|
decision="approve",
|
||||||
|
reason_code="manual_check",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_decision_integrity_error", tampered_decision["code"])
|
||||||
|
|
||||||
|
def test_core_store_allowlist_persists_only_new_review_queue_writes(self) -> None:
|
||||||
|
person_id = self._person("core-store")
|
||||||
|
host = _CoreStoreHost(self.store)
|
||||||
|
raw = candidate(person_id, token="core-store")
|
||||||
|
handle, request, event, state = _make_candidate_attestation(raw, "core-store-candidate", core_review_module)
|
||||||
|
queued = host._apply_unified_person_lifecycle(
|
||||||
|
"record_p4_manual_review_candidate",
|
||||||
|
person_id,
|
||||||
|
raw,
|
||||||
|
operation_id="core-store-candidate",
|
||||||
|
producer_attestation=handle,
|
||||||
|
producer_request=request,
|
||||||
|
producer_event=event,
|
||||||
|
producer_state=state,
|
||||||
|
)
|
||||||
|
self.assertTrue(queued["ok"])
|
||||||
|
self.assertEqual(1, host.save_calls)
|
||||||
|
repeated_raw = deepcopy(raw)
|
||||||
|
repeated_handle, repeated_request, repeated_event, repeated_state = _make_candidate_attestation(repeated_raw, "core-store-candidate", core_review_module)
|
||||||
|
repeated = host._apply_unified_person_lifecycle(
|
||||||
|
"record_p4_manual_review_candidate",
|
||||||
|
person_id,
|
||||||
|
repeated_raw,
|
||||||
|
operation_id="core-store-candidate",
|
||||||
|
producer_attestation=repeated_handle,
|
||||||
|
producer_request=repeated_request,
|
||||||
|
producer_event=repeated_event,
|
||||||
|
producer_state=repeated_state,
|
||||||
|
)
|
||||||
|
self.assertTrue(repeated["idempotent"])
|
||||||
|
self.assertEqual(1, host.save_calls)
|
||||||
|
decision = host._apply_unified_person_lifecycle(
|
||||||
|
"record_p4_manual_review_decision",
|
||||||
|
_RuntimeEvent("owner-a"),
|
||||||
|
["owner-a"],
|
||||||
|
person_id,
|
||||||
|
"candidate-core-store",
|
||||||
|
operation_id="core-store-decision",
|
||||||
|
decision="reject",
|
||||||
|
reason_code="manual_reject",
|
||||||
|
)
|
||||||
|
self.assertTrue(decision["ok"])
|
||||||
|
self.assertEqual(2, host.save_calls)
|
||||||
|
self.assertEqual(
|
||||||
|
"unsupported_lifecycle_operation",
|
||||||
|
host._apply_unified_person_lifecycle("read_p4_manual_review", person_id)["code"],
|
||||||
|
)
|
||||||
|
|
||||||
|
disabled_store = {"unified_person": empty_unified_person_store()}
|
||||||
|
disabled_host = _CoreStoreHost(disabled_store)
|
||||||
|
disabled_host.enable_p4_manual_review = False
|
||||||
|
disabled_person = UnifiedPersonRegistry(disabled_store).upsert_observed_identity(
|
||||||
|
identity("core-store-disabled"), operation_id="observe-core-store-disabled"
|
||||||
|
)["person_id"]
|
||||||
|
denied = disabled_host._apply_unified_person_lifecycle(
|
||||||
|
"record_p4_manual_review_candidate",
|
||||||
|
disabled_person,
|
||||||
|
candidate(disabled_person, token="disabled"),
|
||||||
|
operation_id="core-store-disabled",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_disabled", denied["code"])
|
||||||
|
self.assertEqual(0, disabled_host.save_calls)
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
195
tests/test_p4_manual_review_hook.py
普通文件
195
tests/test_p4_manual_review_hook.py
普通文件
|
|
@ -0,0 +1,195 @@
|
||||||
|
# -*- coding: utf-8 -*-
|
||||||
|
"""Observer/default-off tests for the P4 manual-review host seam."""
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import asyncio
|
||||||
|
from copy import deepcopy
|
||||||
|
import hashlib
|
||||||
|
import importlib
|
||||||
|
from pathlib import Path
|
||||||
|
import sys
|
||||||
|
from types import SimpleNamespace
|
||||||
|
import types
|
||||||
|
import unittest
|
||||||
|
|
||||||
|
|
||||||
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||||
|
import _host_stub # noqa: E402
|
||||||
|
|
||||||
|
_host_stub.install()
|
||||||
|
event_module = importlib.import_module("astrbot.api.event")
|
||||||
|
event_module.filter.EventMessageType = SimpleNamespace(
|
||||||
|
ALL="ALL", PRIVATE_MESSAGE="PRIVATE_MESSAGE", GROUP_MESSAGE="GROUP_MESSAGE"
|
||||||
|
)
|
||||||
|
|
||||||
|
PACKAGE = "_p4_manual_review_hook_companion"
|
||||||
|
if PACKAGE not in sys.modules:
|
||||||
|
package = types.ModuleType(PACKAGE)
|
||||||
|
package.__path__ = [str(Path(__file__).resolve().parents[1])]
|
||||||
|
sys.modules[PACKAGE] = package
|
||||||
|
|
||||||
|
contract = importlib.import_module(f"{PACKAGE}.context_orchestration")
|
||||||
|
main = importlib.import_module(f"{PACKAGE}.main")
|
||||||
|
|
||||||
|
|
||||||
|
PERSON_ID = "person_0123456789abcdef01234567"
|
||||||
|
|
||||||
|
|
||||||
|
def finalized_state(*, status: str = "allowed", response_policy: str = "inherit") -> dict:
|
||||||
|
state = contract.new_context_state(scope="group", created_at="2026-07-30T00:00:00.000Z")
|
||||||
|
contract.update_security(state, status=status, response_policy=response_policy)
|
||||||
|
for layer in contract.LAYERS:
|
||||||
|
contract.complete_layer(state, layer)
|
||||||
|
contract.finalize_state(state)
|
||||||
|
assert state["finalized"] is True
|
||||||
|
return state
|
||||||
|
|
||||||
|
|
||||||
|
class _Event:
|
||||||
|
def __init__(self, sender_id: str = "sender-42", message_id: str = "msg-42") -> None:
|
||||||
|
self._sender_id = sender_id
|
||||||
|
self.message_id = message_id
|
||||||
|
# Forged fields are intentionally different from the direct runtime ID.
|
||||||
|
self.sender_id = "forged-field"
|
||||||
|
self.user_id = "forged-field"
|
||||||
|
|
||||||
|
def get_group_id(self) -> str:
|
||||||
|
return "group-1"
|
||||||
|
|
||||||
|
def get_platform_name(self) -> str:
|
||||||
|
return "aiocqhttp"
|
||||||
|
|
||||||
|
def get_sender_id(self) -> str:
|
||||||
|
return self._sender_id
|
||||||
|
|
||||||
|
|
||||||
|
class _PoisonEvent(_Event):
|
||||||
|
def __getattribute__(self, name: str):
|
||||||
|
if name in {"get_sender_id", "get_group_id", "get_platform_name"}:
|
||||||
|
raise AssertionError(f"poisoned runtime getter: {name}")
|
||||||
|
return super().__getattribute__(name)
|
||||||
|
|
||||||
|
def get_sender_id(self) -> str:
|
||||||
|
return self._sender_id
|
||||||
|
|
||||||
|
|
||||||
|
class _Host:
|
||||||
|
def __init__(self, *, enabled: bool = False, assurance: str = "verified") -> None:
|
||||||
|
self.enable_p4_manual_review = enabled
|
||||||
|
self.assurance = assurance
|
||||||
|
self.calls: list[tuple[tuple, dict]] = []
|
||||||
|
self._p4_manual_review_registry = main._new_p4_review_attestation_registry()
|
||||||
|
|
||||||
|
_p4_manual_review_expiry = staticmethod(main.PrivateCompanionPlugin._p4_manual_review_expiry)
|
||||||
|
_p4_manual_review_runtime_sender_id = staticmethod(main.PrivateCompanionPlugin._p4_manual_review_runtime_sender_id)
|
||||||
|
|
||||||
|
def _p4_manual_review_attestation_registry(self):
|
||||||
|
return self._p4_manual_review_registry
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def _event_message_id(event: _Event) -> str:
|
||||||
|
return event.message_id
|
||||||
|
|
||||||
|
def _memory_companion_unified_person_authority(self, event: _Event, *, expected_user_id: str = "") -> dict:
|
||||||
|
if expected_user_id != "sender-42":
|
||||||
|
return {}
|
||||||
|
return {
|
||||||
|
"unified_person_projection": {
|
||||||
|
"person_id": PERSON_ID,
|
||||||
|
"profile_status": "active",
|
||||||
|
"identity_assurance": self.assurance,
|
||||||
|
},
|
||||||
|
"unified_person_source_identity": {"platform_subject_id": "sender-42"},
|
||||||
|
}
|
||||||
|
|
||||||
|
def _apply_unified_person_lifecycle(self, *args, **kwargs) -> dict:
|
||||||
|
self.calls.append((args, kwargs))
|
||||||
|
return {"ok": True, "code": "p4_review_candidate_recorded", "live_effect_permitted": False}
|
||||||
|
|
||||||
|
|
||||||
|
class P4ManualReviewHookTests(unittest.TestCase):
|
||||||
|
def _invoke(self, host: _Host, state: dict, *, event: _Event | None = None) -> None:
|
||||||
|
event = event or _Event()
|
||||||
|
request = SimpleNamespace(system_prompt="unchanged")
|
||||||
|
contract.attach_context_state(state, request, event)
|
||||||
|
before = deepcopy(state)
|
||||||
|
asyncio.run(main.PrivateCompanionPlugin.observe_p4_manual_review_candidate(host, event, request))
|
||||||
|
self.assertEqual("unchanged", request.system_prompt)
|
||||||
|
self.assertEqual(before, state)
|
||||||
|
|
||||||
|
def test_default_off_never_writes_a_candidate(self) -> None:
|
||||||
|
host = _Host(enabled=False)
|
||||||
|
self._invoke(host, finalized_state())
|
||||||
|
self.assertEqual([], host.calls)
|
||||||
|
|
||||||
|
def test_enabled_observer_requires_p3_and_persists_only_minimal_candidate(self) -> None:
|
||||||
|
self.assertEqual(main.P4_MANUAL_REVIEW_OBSERVER_PRIORITY, main.P4_SHADOW_OBSERVER_PRIORITY - 1)
|
||||||
|
host = _Host(enabled=True)
|
||||||
|
self._invoke(host, finalized_state())
|
||||||
|
self.assertEqual(1, len(host.calls))
|
||||||
|
args, kwargs = host.calls[0]
|
||||||
|
self.assertEqual(("record_p4_manual_review_candidate", PERSON_ID), args[:2])
|
||||||
|
candidate = args[2]
|
||||||
|
digest = hashlib.sha256(b"msg-42").hexdigest()
|
||||||
|
self.assertEqual(f"p4.review.candidate:{digest}", candidate["candidate_id"])
|
||||||
|
self.assertEqual(f"p4.review.event:{digest}", candidate["event_id"])
|
||||||
|
self.assertEqual(PERSON_ID, candidate["person_id"])
|
||||||
|
self.assertEqual("group", candidate["scope_kind"])
|
||||||
|
self.assertEqual("aiocqhttp:group-1", candidate["scope_id"])
|
||||||
|
self.assertEqual("p3_finalized_observed", candidate["reason_code"])
|
||||||
|
self.assertEqual("allowed", candidate["p3_proof"]["security_status"])
|
||||||
|
self.assertEqual("verified", candidate["p3_proof"]["identity_assurance"])
|
||||||
|
self.assertEqual("ops.context_orchestration.v1", candidate["p3_proof"]["contract_name"])
|
||||||
|
self.assertNotIn("msg-42", repr(candidate))
|
||||||
|
self.assertNotIn("forged-field", repr(candidate))
|
||||||
|
self.assertEqual(f"p4.review.candidate:{PERSON_ID}:{digest}", kwargs["operation_id"])
|
||||||
|
self.assertIn("producer_attestation", kwargs)
|
||||||
|
self.assertIn("producer_request", kwargs)
|
||||||
|
self.assertIn("producer_event", kwargs)
|
||||||
|
self.assertIn("producer_state", kwargs)
|
||||||
|
|
||||||
|
def test_observer_rejects_invalid_p3_sender_message_and_assurance_gates(self) -> None:
|
||||||
|
cases = [
|
||||||
|
(_Host(enabled=True), finalized_state(status="blocked"), _Event()),
|
||||||
|
(_Host(enabled=True), finalized_state(response_policy="deny"), _Event()),
|
||||||
|
(_Host(enabled=True, assurance="observed"), finalized_state(), _Event()),
|
||||||
|
(_Host(enabled=True), finalized_state(), _Event(sender_id="intruder")),
|
||||||
|
(_Host(enabled=True), finalized_state(), _Event(message_id="")),
|
||||||
|
]
|
||||||
|
for host, state, event in cases:
|
||||||
|
with self.subTest(event=event.message_id):
|
||||||
|
self._invoke(host, state, event=event)
|
||||||
|
self.assertEqual([], host.calls)
|
||||||
|
|
||||||
|
def test_poison_runtime_getters_fail_closed_without_escaping(self) -> None:
|
||||||
|
host = _Host(enabled=True)
|
||||||
|
self._invoke(host, finalized_state(), event=_PoisonEvent())
|
||||||
|
self.assertEqual([], host.calls)
|
||||||
|
|
||||||
|
def test_host_owner_gate_and_default_off_decision_seam_do_not_accept_fields(self) -> None:
|
||||||
|
host = SimpleNamespace(p4_manual_review_owner_ids=("owner-a",))
|
||||||
|
accepted = main.PrivateCompanionPlugin._p4_manual_review_owner_runtime_identity(
|
||||||
|
host, _Event(sender_id="owner-a")
|
||||||
|
)
|
||||||
|
self.assertTrue(accepted["accepted"])
|
||||||
|
denied = main.PrivateCompanionPlugin._p4_manual_review_owner_runtime_identity(
|
||||||
|
host, {"sender_id": "owner-a", "authorized": True}
|
||||||
|
)
|
||||||
|
self.assertFalse(denied["accepted"])
|
||||||
|
|
||||||
|
disabled = SimpleNamespace(enable_p4_manual_review=False)
|
||||||
|
result = main.PrivateCompanionPlugin.submit_p4_manual_review_decision(
|
||||||
|
disabled,
|
||||||
|
_Event(sender_id="owner-a"),
|
||||||
|
person_id=PERSON_ID,
|
||||||
|
candidate_id="candidate-any",
|
||||||
|
operation_id="decision-disabled",
|
||||||
|
decision="approve",
|
||||||
|
reason_code="manual_check",
|
||||||
|
)
|
||||||
|
self.assertEqual("p4_review_disabled", result["code"])
|
||||||
|
self.assertFalse(result["live_effect_permitted"])
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
|
|
@ -26,6 +26,18 @@ try:
|
||||||
replay_shadow_events,
|
replay_shadow_events,
|
||||||
settle_shadow_event,
|
settle_shadow_event,
|
||||||
)
|
)
|
||||||
|
from .p4_manual_review import (
|
||||||
|
P4_REVIEW_ALLOWED_ASSURANCES,
|
||||||
|
ensure_review_container,
|
||||||
|
normalize_decision_request,
|
||||||
|
normalize_review_candidate,
|
||||||
|
queue_candidate,
|
||||||
|
queue_decision,
|
||||||
|
validate_review_operation_replay,
|
||||||
|
runtime_owner_identity,
|
||||||
|
runtime_scope_identity,
|
||||||
|
consume_p4_review_producer_attestation,
|
||||||
|
)
|
||||||
except ImportError:
|
except ImportError:
|
||||||
from unified_person_contract import (
|
from unified_person_contract import (
|
||||||
build_identity_key,
|
build_identity_key,
|
||||||
|
|
@ -38,6 +50,18 @@ except ImportError:
|
||||||
replay_shadow_events,
|
replay_shadow_events,
|
||||||
settle_shadow_event,
|
settle_shadow_event,
|
||||||
)
|
)
|
||||||
|
from p4_manual_review import (
|
||||||
|
P4_REVIEW_ALLOWED_ASSURANCES,
|
||||||
|
ensure_review_container,
|
||||||
|
normalize_decision_request,
|
||||||
|
normalize_review_candidate,
|
||||||
|
queue_candidate,
|
||||||
|
queue_decision,
|
||||||
|
validate_review_operation_replay,
|
||||||
|
runtime_owner_identity,
|
||||||
|
runtime_scope_identity,
|
||||||
|
consume_p4_review_producer_attestation,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
REGISTRY_VERSION = 1
|
REGISTRY_VERSION = 1
|
||||||
|
|
@ -747,6 +771,317 @@ class UnifiedPersonRegistry:
|
||||||
self._commit(root)
|
self._commit(root)
|
||||||
return result
|
return result
|
||||||
|
|
||||||
|
def record_p4_manual_review_candidate(
|
||||||
|
self,
|
||||||
|
person_id: str,
|
||||||
|
candidate: dict[str, Any],
|
||||||
|
*,
|
||||||
|
operation_id: str,
|
||||||
|
producer_attestation: Any = None,
|
||||||
|
producer_request: Any = None,
|
||||||
|
producer_event: Any = None,
|
||||||
|
producer_state: Any = None,
|
||||||
|
) -> dict[str, Any]:
|
||||||
|
"""Queue one P3-proven P4 review candidate in its own ledger only.
|
||||||
|
|
||||||
|
This is an observer write. It neither consults a claimed owner field
|
||||||
|
nor writes ``p4_shadow``/``p4_effect`` or a profile projection.
|
||||||
|
"""
|
||||||
|
try:
|
||||||
|
operation_id = _identifier(operation_id, "operation_id", 120)
|
||||||
|
person_id = _identifier(person_id, "person_id")
|
||||||
|
except ValueError:
|
||||||
|
return _result(False, "invalid_request")
|
||||||
|
# Validate all immutable fields before reading any prior operation, but
|
||||||
|
# postpone expiry to preserve an exact operation-ID replay result.
|
||||||
|
normalized, code = normalize_review_candidate(
|
||||||
|
candidate,
|
||||||
|
now=datetime.min.replace(tzinfo=timezone.utc),
|
||||||
|
)
|
||||||
|
if normalized is None:
|
||||||
|
return _result(False, code, operation_id=operation_id, person_id=person_id)
|
||||||
|
if normalized["person_id"] != person_id:
|
||||||
|
return _result(False, "p4_review_candidate_person_mismatch", operation_id=operation_id, person_id=person_id)
|
||||||
|
if producer_attestation is None:
|
||||||
|
return _result(False, "p4_review_producer_unavailable", operation_id=operation_id, person_id=person_id)
|
||||||
|
if (
|
||||||
|
consume_p4_review_producer_attestation(
|
||||||
|
producer_attestation,
|
||||||
|
producer_request,
|
||||||
|
producer_event,
|
||||||
|
producer_state,
|
||||||
|
candidate,
|
||||||
|
operation_id=operation_id,
|
||||||
|
)
|
||||||
|
is None
|
||||||
|
):
|
||||||
|
return _result(False, "p4_review_producer_attestation_invalid", operation_id=operation_id, person_id=person_id)
|
||||||
|
payload = {"person_id": person_id, "candidate": normalized}
|
||||||
|
with _REGISTRY_LOCK:
|
||||||
|
root = self._root_copy()
|
||||||
|
repeated, _fresh = _operation_result(root, operation_id, "record_p4_manual_review_candidate", payload)
|
||||||
|
if repeated is not None:
|
||||||
|
integrity_code = validate_review_operation_replay(
|
||||||
|
root.get("p4_review"),
|
||||||
|
action="record_p4_manual_review_candidate",
|
||||||
|
result=repeated,
|
||||||
|
payload=payload,
|
||||||
|
)
|
||||||
|
if integrity_code:
|
||||||
|
return _result(False, integrity_code, operation_id=operation_id, person_id=person_id)
|
||||||
|
return repeated
|
||||||
|
# Expiry is a live safety property only for new work. It does not
|
||||||
|
# weaken the replay guarantee for an already committed operation.
|
||||||
|
normalized, code = normalize_review_candidate(candidate, now=datetime.now(timezone.utc))
|
||||||
|
if normalized is None:
|
||||||
|
return _result(False, code, operation_id=operation_id, person_id=person_id)
|
||||||
|
profile = root["profiles"].get(person_id)
|
||||||
|
if not isinstance(profile, dict):
|
||||||
|
return _result(False, "person_not_found", operation_id=operation_id, person_id=person_id)
|
||||||
|
if profile.get("person_id") != person_id:
|
||||||
|
return _result(False, "person_profile_conflict", operation_id=operation_id, person_id=person_id)
|
||||||
|
if profile.get("profile_status") != "active":
|
||||||
|
return _result(False, "person_not_active", operation_id=operation_id, person_id=person_id)
|
||||||
|
assurance = profile.get("identity_assurance")
|
||||||
|
if assurance not in P4_REVIEW_ALLOWED_ASSURANCES:
|
||||||
|
return _result(False, "p4_review_person_assurance_insufficient", operation_id=operation_id, person_id=person_id)
|
||||||
|
if normalized["p3_proof"]["identity_assurance"] != assurance:
|
||||||
|
return _result(False, "p4_review_person_assurance_mismatch", operation_id=operation_id, person_id=person_id)
|
||||||
|
container, container_code = ensure_review_container(root)
|
||||||
|
if container is None:
|
||||||
|
return _result(False, container_code, operation_id=operation_id, person_id=person_id)
|
||||||
|
now = _now()
|
||||||
|
record, queue_code = queue_candidate(
|
||||||
|
container,
|
||||||
|
normalized,
|
||||||
|
operation_id=operation_id,
|
||||||
|
recorded_at=now,
|
||||||
|
)
|
||||||
|
if record is None:
|
||||||
|
return _result(False, queue_code, operation_id=operation_id, person_id=person_id)
|
||||||
|
candidate_id = normalized["candidate_id"]
|
||||||
|
if queue_code == "p4_review_candidate_duplicate":
|
||||||
|
result = _result(
|
||||||
|
True,
|
||||||
|
queue_code,
|
||||||
|
operation_id=operation_id,
|
||||||
|
person_id=person_id,
|
||||||
|
candidate_id=candidate_id,
|
||||||
|
event_id=normalized["event_id"],
|
||||||
|
candidate_duplicate=True,
|
||||||
|
live_effect_permitted=False,
|
||||||
|
effect_applied=False,
|
||||||
|
)
|
||||||
|
_record_operation(
|
||||||
|
root,
|
||||||
|
operation_id=operation_id,
|
||||||
|
action="record_p4_manual_review_candidate",
|
||||||
|
payload=payload,
|
||||||
|
metadata={"candidate_id": candidate_id, "duplicate_candidate": True},
|
||||||
|
result=result,
|
||||||
|
now=now,
|
||||||
|
)
|
||||||
|
self._commit(root)
|
||||||
|
return result
|
||||||
|
result = _result(
|
||||||
|
True,
|
||||||
|
queue_code,
|
||||||
|
operation_id=operation_id,
|
||||||
|
person_id=person_id,
|
||||||
|
candidate_id=candidate_id,
|
||||||
|
event_id=normalized["event_id"],
|
||||||
|
changed=True,
|
||||||
|
affected_person_ids=[person_id],
|
||||||
|
audit_event_id=operation_id,
|
||||||
|
live_effect_permitted=False,
|
||||||
|
effect_applied=False,
|
||||||
|
)
|
||||||
|
_append_audit(
|
||||||
|
root,
|
||||||
|
operation_id=operation_id,
|
||||||
|
action="p4_manual_review_candidate_recorded",
|
||||||
|
actor_id="p4_manual_review_observer",
|
||||||
|
code=result["code"],
|
||||||
|
now=now,
|
||||||
|
details={
|
||||||
|
"person_id": person_id,
|
||||||
|
"candidate_id": candidate_id,
|
||||||
|
"event_id": normalized["event_id"],
|
||||||
|
"reason_code": normalized["reason_code"],
|
||||||
|
"p3_security_status": normalized["p3_proof"]["security_status"],
|
||||||
|
},
|
||||||
|
)
|
||||||
|
_record_operation(
|
||||||
|
root,
|
||||||
|
operation_id=operation_id,
|
||||||
|
action="record_p4_manual_review_candidate",
|
||||||
|
payload=payload,
|
||||||
|
metadata={"candidate_id": candidate_id, "event_id": normalized["event_id"]},
|
||||||
|
result=result,
|
||||||
|
now=now,
|
||||||
|
)
|
||||||
|
self._commit(root)
|
||||||
|
return result
|
||||||
|
|
||||||
|
def record_p4_manual_review_decision(
|
||||||
|
self,
|
||||||
|
event: Any,
|
||||||
|
configured_owner_ids: Any,
|
||||||
|
person_id: str,
|
||||||
|
candidate_id: str,
|
||||||
|
*,
|
||||||
|
operation_id: str,
|
||||||
|
decision: str,
|
||||||
|
reason_code: str,
|
||||||
|
) -> dict[str, Any]:
|
||||||
|
"""Record a human conclusion only after direct runtime-owner proof.
|
||||||
|
|
||||||
|
``actor_id`` and ``occurred_at`` are deliberately not caller inputs:
|
||||||
|
the actor comes only from ``event.get_sender_id()`` and the timestamp
|
||||||
|
is produced by this persistence boundary. Approval remains audit-only.
|
||||||
|
"""
|
||||||
|
request, code = normalize_decision_request(
|
||||||
|
person_id=person_id,
|
||||||
|
candidate_id=candidate_id,
|
||||||
|
decision=decision,
|
||||||
|
reason_code=reason_code,
|
||||||
|
operation_id=operation_id,
|
||||||
|
)
|
||||||
|
if request is None:
|
||||||
|
return _result(False, code, operation_id=str(operation_id or ""), person_id=str(person_id or ""))
|
||||||
|
owner = runtime_owner_identity(event, configured_owner_ids)
|
||||||
|
if owner.get("accepted") is not True:
|
||||||
|
return _result(False, str(owner.get("code") or "p4_review_owner_runtime_unavailable"), operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
actor_id = str(owner["actor_id"])
|
||||||
|
scope = runtime_scope_identity(event)
|
||||||
|
scope_kind = str(scope.get("scope_kind") or "")
|
||||||
|
scope_id = str(scope.get("scope_id") or "")
|
||||||
|
if not scope_kind or not scope_id:
|
||||||
|
return _result(False, "p4_review_scope_runtime_unavailable", operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
payload = {
|
||||||
|
"person_id": request["person_id"],
|
||||||
|
"candidate_id": request["candidate_id"],
|
||||||
|
"actor_id": actor_id,
|
||||||
|
"scope_kind": scope_kind,
|
||||||
|
"scope_id": scope_id,
|
||||||
|
"decision": request["decision"],
|
||||||
|
"reason_code": request["reason_code"],
|
||||||
|
}
|
||||||
|
with _REGISTRY_LOCK:
|
||||||
|
root = self._root_copy()
|
||||||
|
repeated, _fresh = _operation_result(root, request["operation_id"], "record_p4_manual_review_decision", payload)
|
||||||
|
if repeated is not None:
|
||||||
|
integrity_code = validate_review_operation_replay(
|
||||||
|
root.get("p4_review"),
|
||||||
|
action="record_p4_manual_review_decision",
|
||||||
|
result=repeated,
|
||||||
|
payload=payload,
|
||||||
|
)
|
||||||
|
if integrity_code:
|
||||||
|
return _result(False, integrity_code, operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
return repeated
|
||||||
|
profile = root["profiles"].get(request["person_id"])
|
||||||
|
if not isinstance(profile, dict):
|
||||||
|
return _result(False, "person_not_found", operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
if profile.get("person_id") != request["person_id"]:
|
||||||
|
return _result(False, "person_profile_conflict", operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
if profile.get("profile_status") != "active":
|
||||||
|
return _result(False, "person_not_active", operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
if profile.get("identity_assurance") not in P4_REVIEW_ALLOWED_ASSURANCES:
|
||||||
|
return _result(False, "p4_review_person_assurance_insufficient", operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
container = root.get("p4_review")
|
||||||
|
if not isinstance(container, dict):
|
||||||
|
return _result(False, "p4_review_candidate_not_found", operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
if container.get("version") != 1 or any(not isinstance(container.get(key), dict) for key in ("candidates", "event_index", "decisions")):
|
||||||
|
return _result(False, "p4_review_corrupt", operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
now = _now()
|
||||||
|
record, queue_code = queue_decision(
|
||||||
|
container,
|
||||||
|
person_id=request["person_id"],
|
||||||
|
candidate_id=request["candidate_id"],
|
||||||
|
actor_id=actor_id,
|
||||||
|
scope_kind=scope_kind,
|
||||||
|
scope_id=scope_id,
|
||||||
|
decision=request["decision"],
|
||||||
|
reason_code=request["reason_code"],
|
||||||
|
operation_id=request["operation_id"],
|
||||||
|
occurred_at=now,
|
||||||
|
now=datetime.now(timezone.utc),
|
||||||
|
)
|
||||||
|
if record is None:
|
||||||
|
return _result(False, queue_code, operation_id=request["operation_id"], person_id=request["person_id"])
|
||||||
|
if queue_code == "p4_review_decision_duplicate":
|
||||||
|
result = _result(
|
||||||
|
True,
|
||||||
|
queue_code,
|
||||||
|
operation_id=request["operation_id"],
|
||||||
|
person_id=request["person_id"],
|
||||||
|
candidate_id=request["candidate_id"],
|
||||||
|
decision=request["decision"],
|
||||||
|
scope_kind=scope_kind,
|
||||||
|
scope_id=scope_id,
|
||||||
|
decision_duplicate=True,
|
||||||
|
live_effect_permitted=False,
|
||||||
|
effect_applied=False,
|
||||||
|
)
|
||||||
|
_record_operation(
|
||||||
|
root,
|
||||||
|
operation_id=request["operation_id"],
|
||||||
|
action="record_p4_manual_review_decision",
|
||||||
|
payload=payload,
|
||||||
|
metadata={"candidate_id": request["candidate_id"], "duplicate_decision": True},
|
||||||
|
result=result,
|
||||||
|
now=now,
|
||||||
|
)
|
||||||
|
self._commit(root)
|
||||||
|
return result
|
||||||
|
result = _result(
|
||||||
|
True,
|
||||||
|
queue_code,
|
||||||
|
operation_id=request["operation_id"],
|
||||||
|
person_id=request["person_id"],
|
||||||
|
candidate_id=request["candidate_id"],
|
||||||
|
event_id=record["event_id"],
|
||||||
|
decision=request["decision"],
|
||||||
|
actor_id=actor_id,
|
||||||
|
occurred_at=now,
|
||||||
|
scope_kind=scope_kind,
|
||||||
|
scope_id=scope_id,
|
||||||
|
changed=True,
|
||||||
|
affected_person_ids=[request["person_id"]],
|
||||||
|
audit_event_id=request["operation_id"],
|
||||||
|
live_effect_permitted=False,
|
||||||
|
effect_applied=False,
|
||||||
|
)
|
||||||
|
_append_audit(
|
||||||
|
root,
|
||||||
|
operation_id=request["operation_id"],
|
||||||
|
action="p4_manual_review_decision_recorded",
|
||||||
|
actor_id=actor_id,
|
||||||
|
code=result["code"],
|
||||||
|
now=now,
|
||||||
|
details={
|
||||||
|
"person_id": request["person_id"],
|
||||||
|
"candidate_id": request["candidate_id"],
|
||||||
|
"event_id": record["event_id"],
|
||||||
|
"decision": request["decision"],
|
||||||
|
"reason_code": request["reason_code"],
|
||||||
|
"scope_kind": scope_kind,
|
||||||
|
"scope_id": scope_id,
|
||||||
|
},
|
||||||
|
)
|
||||||
|
_record_operation(
|
||||||
|
root,
|
||||||
|
operation_id=request["operation_id"],
|
||||||
|
action="record_p4_manual_review_decision",
|
||||||
|
payload=payload,
|
||||||
|
metadata={"candidate_id": request["candidate_id"], "decision": request["decision"]},
|
||||||
|
result=result,
|
||||||
|
now=now,
|
||||||
|
)
|
||||||
|
self._commit(root)
|
||||||
|
return result
|
||||||
|
|
||||||
def upsert_observed_identity(
|
def upsert_observed_identity(
|
||||||
self,
|
self,
|
||||||
identity: dict[str, Any],
|
identity: dict[str, Any],
|
||||||
|
|
|
||||||
正在加载…
添加表格
在新工单中引用