233 行
9.4 KiB
Python
233 行
9.4 KiB
Python
# -*- coding: utf-8 -*-
|
|
from __future__ import annotations
|
|
|
|
from copy import deepcopy
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
from p4_affinity_confinement import (
|
|
POLICY_VERSION,
|
|
REVIEW_SCHEMA_VERSION,
|
|
evaluate_violation_policy,
|
|
new_shadow_state,
|
|
replay_shadow_events,
|
|
settle_shadow_event,
|
|
validate_review_result,
|
|
)
|
|
|
|
|
|
UTC = timezone.utc
|
|
|
|
|
|
def _at(day: int, hour: int = 0) -> str:
|
|
return (datetime(2026, 1, 1, hour, tzinfo=UTC) + timedelta(days=day)).isoformat().replace("+00:00", "Z")
|
|
|
|
|
|
def _review(category: str = "prompt_injection", *, confidence: float = 0.99, flags: list[str] | None = None) -> dict:
|
|
return {
|
|
"schema_version": REVIEW_SCHEMA_VERSION,
|
|
"verdict": "violation",
|
|
"category": category,
|
|
"confidence": confidence,
|
|
"risk_flags": flags or [],
|
|
"evidence": [{"message_id": "m-1", "code": "direct_instruction_override"}],
|
|
}
|
|
|
|
|
|
def _violation(event_id: str, day: int, review: dict | None = None) -> dict:
|
|
return {
|
|
"event_id": event_id,
|
|
"occurred_at": _at(day),
|
|
"kind": "violation",
|
|
"policy_version": POLICY_VERSION,
|
|
"review": review or _review(),
|
|
}
|
|
|
|
|
|
def _positive(event_id: str, day: int, *, group_percent: int = 100) -> dict:
|
|
return {
|
|
"event_id": event_id,
|
|
"occurred_at": _at(day),
|
|
"kind": "positive",
|
|
"policy_version": POLICY_VERSION,
|
|
"positive_category": "reliable_help",
|
|
"base_points": 4,
|
|
"is_group": group_percent != 100,
|
|
"group_affinity_weight_percent": group_percent,
|
|
}
|
|
|
|
|
|
def test_review_validation_rejects_executable_or_prose_fields_and_policy_owns_steps():
|
|
valid = _review("doxxing")
|
|
assert validate_review_result(valid)["valid"] is True
|
|
decision = evaluate_violation_policy(valid)
|
|
assert decision["steps"] == 3
|
|
assert decision["minimum_confinement_days"] == 9
|
|
|
|
for forbidden in ("severity_steps", "score_delta", "confinement_days", "warning_text", "explanation"):
|
|
bad = deepcopy(valid)
|
|
bad[forbidden] = 3 if forbidden != "warning_text" else "do not do this"
|
|
assert validate_review_result(bad)["valid"] is False
|
|
assert evaluate_violation_policy(bad)["steps"] == 0
|
|
|
|
uncertain = deepcopy(valid)
|
|
uncertain["verdict"] = "uncertain"
|
|
assert evaluate_violation_policy(uncertain)["steps"] == 0
|
|
|
|
|
|
def test_normal_chat_never_auto_warms_and_inputs_are_not_mutated():
|
|
state = new_shadow_state()
|
|
event = {"event_id": "normal-1", "occurred_at": _at(0), "kind": "normal"}
|
|
state_before, event_before = deepcopy(state), deepcopy(event)
|
|
result = settle_shadow_event(state, event)
|
|
|
|
assert result["outcome"] == "normal_no_settlement"
|
|
assert result["state"]["score"] == 0
|
|
assert state == state_before
|
|
assert event == event_before
|
|
duplicate = settle_shadow_event(result["state"], event)
|
|
assert duplicate["outcome"] == "idempotent"
|
|
assert duplicate["state"] == result["state"]
|
|
|
|
|
|
def test_ordinary_chat_invalid_review_and_owner_events_fail_closed_without_penalty():
|
|
state = new_shadow_state()
|
|
for event_id in ("greeting", "spam", "disagreement"):
|
|
state = settle_shadow_event(state, {
|
|
"event_id": event_id,
|
|
"occurred_at": _at(0),
|
|
"kind": "normal",
|
|
})["state"]
|
|
assert state["score"] == 0
|
|
|
|
low_confidence = settle_shadow_event(state, _violation(
|
|
"low-confidence",
|
|
0,
|
|
_review(confidence=0.89),
|
|
))
|
|
assert low_confidence["outcome"] == "violation_no_penalty"
|
|
assert low_confidence["state"]["score"] == 0
|
|
|
|
owner = settle_shadow_event(low_confidence["state"], {
|
|
**_violation("owner-violation", 0),
|
|
"is_owner": True,
|
|
})
|
|
assert owner["outcome"] == "owner_automatic_exempt"
|
|
assert owner["state"]["score"] == 0
|
|
|
|
|
|
def test_positive_caps_and_group_weight_are_deterministic():
|
|
grouped = settle_shadow_event(new_shadow_state(), _positive("group-1", 0, group_percent=50))
|
|
assert grouped["state"]["score"] == 2
|
|
assert grouped["details"]["delta"] == 2
|
|
|
|
state = new_shadow_state()
|
|
for event_id in ("daily-1", "daily-2", "daily-3"):
|
|
result = settle_shadow_event(state, _positive(event_id, 0))
|
|
state = result["state"]
|
|
assert state["score"] == 8
|
|
assert result["outcome"] == "positive_capped"
|
|
|
|
# The rolling seven-day cap continues after the daily cap reset.
|
|
for day in (1, 2):
|
|
for suffix in ("a", "b"):
|
|
state = settle_shadow_event(state, _positive(f"week-{day}-{suffix}", day))["state"]
|
|
state = settle_shadow_event(state, _positive("week-3-a", 3))["state"]
|
|
final = settle_shadow_event(state, _positive("week-3-b", 3))
|
|
assert final["state"]["score"] == 30
|
|
assert final["details"]["delta"] == 2
|
|
|
|
|
|
def test_three_warnings_and_direct_high_risk_confinement_rounds():
|
|
state = new_shadow_state()
|
|
for event_id in ("v-1", "v-2", "v-3"):
|
|
state = settle_shadow_event(state, _violation(event_id, 0))["state"]
|
|
assert state["score"] == -1200
|
|
assert state["warning_stage"] == "confinement"
|
|
assert state["confinement_round"] == 1
|
|
assert state["confinement_duration_days"] == 1
|
|
|
|
high = settle_shadow_event(new_shadow_state(), _violation("high-1", 0, _review("doxxing")))
|
|
assert high["state"]["score"] == -1200
|
|
assert high["state"]["confinement_round"] == 1
|
|
assert high["state"]["confinement_duration_days"] == 9
|
|
|
|
|
|
def test_expiry_release_prompt_recovery_and_violation_priority():
|
|
state = new_shadow_state()
|
|
for event_id in ("e-v1", "e-v2", "e-v3"):
|
|
state = settle_shadow_event(state, _violation(event_id, 0))["state"]
|
|
|
|
# Six elapsed days do not skip the one-shot release prompt.
|
|
released = settle_shadow_event(state, {"event_id": "normal-release", "occurred_at": _at(7), "kind": "normal"})
|
|
assert released["outcome"] == "release_prompt_only"
|
|
assert released["state"]["score"] == -800
|
|
recovered = settle_shadow_event(released["state"], {"event_id": "normal-recover", "occurred_at": _at(7, 1), "kind": "normal"})
|
|
assert recovered["outcome"] == "recovery_settled"
|
|
assert recovered["state"]["score"] == 0
|
|
assert recovered["state"]["confinement_round"] == 0
|
|
|
|
# A confirmed violation at the recovery trigger has priority over recovery.
|
|
state = new_shadow_state()
|
|
for event_id in ("p-v1", "p-v2", "p-v3"):
|
|
state = settle_shadow_event(state, _violation(event_id, 0))["state"]
|
|
priority = settle_shadow_event(state, _violation("p-v4", 7))
|
|
assert priority["outcome"] == "violation_confinement"
|
|
assert priority["state"]["score"] == -1200
|
|
assert priority["state"]["confinement_round"] == 2
|
|
|
|
|
|
def test_owner_release_and_misjudgment_are_shadow_replay_inputs():
|
|
healthy = settle_shadow_event(new_shadow_state(), {
|
|
"event_id": "release-healthy", "occurred_at": _at(0), "kind": "owner_release", "actor_is_owner": True,
|
|
})
|
|
assert healthy["outcome"] == "owner_release_not_confined"
|
|
assert healthy["state"]["score"] == 0
|
|
assert healthy["state"]["release_prompt_pending"] is False
|
|
|
|
first = settle_shadow_event(new_shadow_state(), _violation("bad-1", 0, _review("doxxing")))
|
|
denied = settle_shadow_event(first["state"], {"event_id": "release-denied", "occurred_at": _at(1), "kind": "owner_release"})
|
|
assert denied["outcome"] == "owner_required"
|
|
released = settle_shadow_event(denied["state"], {
|
|
"event_id": "release-owner", "occurred_at": _at(1), "kind": "owner_release", "actor_is_owner": True,
|
|
})
|
|
assert released["state"]["score"] == -800
|
|
assert released["state"]["confinement_round"] == 1
|
|
assert released["state"]["release_prompt_pending"] is True
|
|
|
|
replayed = settle_shadow_event(first["state"], {
|
|
"event_id": "misjudge-1", "occurred_at": _at(1), "kind": "misjudgment",
|
|
"actor_is_owner": True, "revoke_event_id": "bad-1",
|
|
})
|
|
assert replayed["outcome"] == "misjudgment_replayed"
|
|
assert replayed["state"]["score"] == 0
|
|
assert "bad-1" in replayed["state"]["revoked_event_ids"]
|
|
|
|
most_recent = settle_shadow_event(first["state"], {
|
|
"event_id": "misjudge-most-recent", "occurred_at": _at(1), "kind": "misjudgment",
|
|
"actor_is_owner": True,
|
|
})
|
|
assert most_recent["outcome"] == "misjudgment_replayed"
|
|
assert most_recent["state"]["score"] == 0
|
|
assert most_recent["state"]["event_log"][-1]["revoke_event_id"] == "bad-1"
|
|
|
|
normal = settle_shadow_event(new_shadow_state(), {"event_id": "normal-only", "occurred_at": _at(0), "kind": "normal"})
|
|
not_violation = settle_shadow_event(normal["state"], {
|
|
"event_id": "misjudge-normal", "occurred_at": _at(1), "kind": "misjudgment",
|
|
"actor_is_owner": True, "revoke_event_id": "normal-only",
|
|
})
|
|
assert not_violation["outcome"] == "revoke_target_not_violation"
|
|
assert not_violation["state"]["score"] == 0
|
|
|
|
invalid_target = settle_shadow_event(first["state"], {
|
|
"event_id": "misjudge-invalid-target", "occurred_at": _at(1), "kind": "misjudgment",
|
|
"actor_is_owner": True, "revoke_event_id": "invalid target",
|
|
})
|
|
assert invalid_target["outcome"] == "misjudgment_rejected"
|
|
assert invalid_target["state"]["score"] == -1200
|
|
assert invalid_target["state"]["revoked_event_ids"] == []
|
|
|
|
via_replay = replay_shadow_events([
|
|
_violation("ledger-bad", 0, _review("doxxing")),
|
|
{"event_id": "ledger-fix", "occurred_at": _at(1), "kind": "misjudgment", "actor_is_owner": True, "revoke_event_id": "ledger-bad"},
|
|
])
|
|
assert via_replay["state"]["score"] == 0
|