diff --git a/_conf_schema.json b/_conf_schema.json index 29e829e..e76be63 100644 --- a/_conf_schema.json +++ b/_conf_schema.json @@ -225,6 +225,15 @@ "default": 0, "condition": "enable_auto_user_profile_creation" }, + "default_interaction_band": { + "description": "新档案默认互动状态", + "type": "string", + "options": ["avoidant", "hurt", "relaxed", "lively", "warm"], + "labels": ["回避", "受伤", "放松", "活泼", "温暖"], + "hint": "只影响之后自动建立的普通用户档案;亲近和爱意仅允许管理员专属账户使用。", + "default": "relaxed", + "condition": "enable_auto_user_profile_creation" + }, "default_proactive_enabled": { "description": "允许新用户主动关心", "type": "bool", @@ -253,6 +262,87 @@ "default": "", "invisible": true }, + "owner_exclusive_label": { + "description": "管理员专属关系名称", + "type": "string", + "hint": "仅用于 owner 专属关系的显示和表达,不授予额外权限。", + "default": "专属联结" + }, + "owner_exclusive_tone": { + "description": "管理员专属基础表达", + "type": "string", + "hint": "专属关系的长期表达基线;当前互动状态和安全边界仍可使表达收敛。", + "default": "温暖、亲近、稳定" + }, + "owner_exclusive_address_style": { + "description": "管理员专属称呼尺度", + "type": "string", + "hint": "优先沿用用户档案中双方已确认的专属称呼。", + "default": "优先使用已确认的专属称呼" + }, + "owner_exclusive_proactive_limit": { + "description": "管理员专属主动阶段上限", + "type": "int", + "slider": {"min": 0, "max": 30, "step": 1}, + "hint": "只是阶段硬上限;实际次数仍取全局、用户、阶段和动态额度的最小值。", + "default": 6 + }, + "relationship_event_window_minutes": { + "description": "亲密度事件去重窗口(分钟)", + "type": "int", + "slider": {"min": 1, "max": 1440, "step": 1}, + "hint": "同一原因在窗口内只结算一次,避免短时间刷消息重复加分。", + "default": 30 + }, + "relationship_positive_event_cap": { + "description": "单次正向亲密度上限", + "type": "int", + "slider": {"min": 1, "max": 30, "step": 1}, + "hint": "单个事件最多增加多少分。", + "default": 4 + }, + "relationship_negative_event_cap": { + "description": "单次负向亲密度上限", + "type": "int", + "slider": {"min": 1, "max": 60, "step": 1}, + "hint": "单个明确负向事件最多扣多少分。普通未回复不会直接扣长期分。", + "default": 12 + }, + "relationship_positive_daily_cap": { + "description": "每日正向亲密度上限", + "type": "int", + "slider": {"min": 0, "max": 120, "step": 1}, + "hint": "限制单日累计正向增长;0 表示当天不自动增加。", + "default": 12 + }, + "relationship_decay_grace_days": { + "description": "自然回落宽限天数", + "type": "int", + "slider": {"min": 0, "max": 30, "step": 1}, + "hint": "连续多少天没有有效互动时保持不变;默认 3 天。", + "default": 3 + }, + "relationship_decay_early_per_day": { + "description": "回落前段每日扣分", + "type": "int", + "slider": {"min": 0, "max": 30, "step": 1}, + "hint": "宽限后至第 7 个未互动日每天回落多少分。", + "default": 2 + }, + "relationship_decay_middle_per_day": { + "description": "回落中段每日扣分", + "type": "int", + "slider": {"min": 0, "max": 30, "step": 1}, + "hint": "第 8 至第 14 个未互动日每天回落多少分。", + "default": 5 + }, + "relationship_decay_late_per_day": { + "description": "回落后段每日扣分", + "type": "int", + "slider": {"min": 0, "max": 30, "step": 1}, + "hint": "第 15 个未互动日起每天回落多少分;只向 0 回落。", + "default": 8 + }, "default_nickname": { "description": "默认称呼", "type": "string", @@ -1490,9 +1580,9 @@ "invisible": true }, "enable_relationship_analysis": { - "description": "Legacy flat config: 启用模型关系站位分析", + "description": "Legacy flat config: 已停用的模型关系站位分析", "type": "bool", - "default": true, + "default": false, "invisible": true }, "enable_emotion_simulation": { @@ -4285,7 +4375,7 @@ "EMOTION_JUDGEMENT_PROVIDER_ID": { "description": "情绪变化判断模型(留空自动回退)", "type": "string", - "hint": "用于可选复核用户消息是否会触发 Bot 自身短期情绪余波。建议选择便宜、低延迟、分类保守的小模型;留空会先回退到排障检查模型,再回退到关系站位/陪伴通用/主模型。", + "hint": "用于可选复核用户消息是否应改变统一互动状态。建议选择便宜、低延迟、分类保守的小模型;留空会先回退到排障检查模型,再回退到陪伴通用/主模型。", "default": "", "condition": { "provider_config_mode": "precision" @@ -5923,9 +6013,9 @@ } }, "emotion_relationship_config": { - "description": "意图与关系状态", + "description": "意图与互动状态", "type": "object", - "hint": "维护用户意图、关系温度、回复策略和边界收敛;Bot 自身情绪模拟已移至“实验性功能”。", + "hint": "维护本轮意图识别、七档互动状态和明确联系边界;长期关系基线、短期修正与安全约束最终统一结算为一份表达决策。", "items": { "enable_intent_emotion_analysis": { "description": "启用本地意图/情绪快判", @@ -5937,22 +6027,20 @@ } }, "enable_relationship_state_machine": { - "description": "启用关系距离感", + "description": "让关系事件调整互动状态", "type": "bool", - "hint": "根据用户的边界、亲近、冷淡、玩笑、长期互动和是否回应主动消息,调整 Bot 的距离感、主动频率和相处分寸。Bot 自身被刺到后的短期余波由“实验性功能 → 情绪模拟”单独控制。", + "hint": "根据明确边界、重新靠近、玩笑、亲近和互动压力更新统一七档互动状态;明确退开另写联系边界,不能被普通状态调整绕过。", "default": true, "condition": { "enable_mai_style_integration": true } }, "enable_relationship_analysis": { - "description": "启用模型关系站位分析", + "description": "旧版模型关系站位分析(已由陪伴表达系统取代)", "type": "bool", - "hint": "阶段性使用完整人格和互动数据,让模型复核陌生/熟悉/亲近及打扰偏好。关闭后不再产生“关系分析”模型 Token;关系距离感、本地边界判断和基于互动次数/回复率的兜底仍可继续工作。", - "default": true, - "condition": { - "enable_mai_style_integration": true - } + "hint": "仅保留旧配置读取兼容;运行时不再调用模型生成第二套关系层级。", + "default": false, + "invisible": true }, "enable_response_self_review": { "description": "旧版回复/主动复核总开关", @@ -10434,7 +10522,7 @@ "experimental_motivation_config": { "description": "实验性功能", "type": "object", - "hint": "心理机制、动机调度、角色贴合校准和情绪余波等探索性功能。除已存在的情绪模拟会保留原默认值外,其它实验项默认关闭;建议逐项开启观察,不把理论标签写进实际回复正文。", + "hint": "心理机制、动机调度和角色贴合校准等探索性功能默认关闭;统一互动状态事件已并入亲密度阶段策略详情,不再作为独立实验系统展示。", "items": { "enable_maslow_motivation_experiment": { "description": "启用需求强化功能", @@ -10487,18 +10575,18 @@ } }, "enable_emotion_simulation": { - "description": "启用情绪模拟", + "description": "让情绪事件自动调整统一互动状态", "type": "bool", - "hint": "实验性情绪余波。维护 Bot 自身短期情绪,例如被刺到后的收敛、缓和后的恢复,以及不满时的短暂回避;会结合四维状态、基本/复合情绪和调节策略影响回复。该项迁入实验性功能但保留原默认值,避免更新后行为突变。", + "hint": "开启后,受伤、道歉、安抚、夸奖、玩笑和亲近事件只结算到陪伴表达系统的统一七档互动状态;不再新增 Izard、Plutchik、Gross、mood_score 或第二套关系状态。旧字段仅保留只读兼容。", "default": true, "condition": { "enable_mai_style_integration": true } }, "enable_llm_emotion_judgement": { - "description": "启用模型复核情绪变化", + "description": "启用模型复核互动状态事件", "type": "bool", - "hint": "开启后,本地快判会先记录;可疑边界、玩笑、道歉、安抚或负向表达会交给模型后台复核,再更新短期情绪余波。本轮被动回复不等待模型,仍使用缓存情绪状态,默认关闭以保持低延迟。", + "hint": "开启后,本地快判会先记录;可疑边界、玩笑、道歉、安抚或负向表达会交给模型后台复核,再更新统一互动状态。本轮被动回复不等待模型,默认关闭以保持低延迟。", "default": false, "condition": { "enable_emotion_simulation": true @@ -10514,9 +10602,9 @@ } }, "emotional_gate_hurt_threshold": { - "description": "伤心触发阈值", + "description": "受伤状态触发阈值", "type": "int", - "hint": "用户消息被判定为足够刺痛且达到该值时,Bot 才会短期变得更安静、更收着。越高越不容易触发;轻度玩笑和普通边界不会直接触发。应低于“生气触发阈值”。", + "hint": "用户消息被判定为足够刺痛且达到该值时,当前互动才进入“受伤”。越高越不容易触发;轻度玩笑和普通边界不会直接触发。应低于“回避状态触发阈值”。", "slider": { "min": 10, "max": 100, @@ -10528,9 +10616,9 @@ } }, "emotional_gate_refuse_threshold": { - "description": "生气触发阈值", + "description": "回避状态触发阈值", "type": "int", - "hint": "累计刺痛感达到该值后,Bot 才会表现出更明显的不满和短暂回避。建议保持较高,只让连续明确伤害触发。", + "hint": "单次明确伤害强度达到该值后,当前互动进入更收敛的“回避”;它不是联系边界,也不会自动写入不再联系。建议高于受伤阈值。", "slider": { "min": 20, "max": 100, @@ -10542,9 +10630,9 @@ } }, "emotional_gate_recovery_per_hour": { - "description": "每小时缓和量", + "description": "每小时恢复量", "type": "int", - "hint": "情绪余波会随时间自然回到稳定;道歉、安抚、夸奖也会额外缓和。", + "hint": "用于计算受伤/回避互动状态的预计持续时间;数值越高,自动回到长期关系基线越快。道歉、安抚和明确重新靠近仍可提前恢复。", "slider": { "min": 1, "max": 60, @@ -10556,9 +10644,9 @@ } }, "emotional_gate_max_hurt_minutes": { - "description": "最长收敛分钟", + "description": "受伤/回避最长持续分钟", "type": "int", - "hint": "单次刺痛事件造成的最长主动暂停/收敛时长。默认较短,避免情绪余波长时间压低回复;道歉或安抚可以提前恢复。", + "hint": "限制单次明确伤害造成的短期互动状态持续时间;到期后回到长期关系基线,道歉或安抚可以提前恢复。", "slider": { "min": 10, "max": 720, diff --git a/companion_interaction_expression.py b/companion_interaction_expression.py new file mode 100644 index 0000000..ef69309 --- /dev/null +++ b/companion_interaction_expression.py @@ -0,0 +1,535 @@ +"""Pure contract for the Companion interaction-expression pipeline. + +The contract deliberately owns no persistence, clock, network, or platform +access. Runtime adapters may pass their already-sanitised snapshots here and +consume the single :class:`ExpressionDecision` result in passive replies, +proactive candidates, TTS, and presentation projections. +""" + +from __future__ import annotations + +from dataclasses import asdict, dataclass +from enum import Enum +from typing import Any, Mapping + + +EXPRESSION_CONTRACT_VERSION = "companion_interaction_expression.v1" + + +class ExpressionBand(str, Enum): + """The seven short-term expression bands, ordered from reserved to warm.""" + + AVOIDANT = "avoidant" + HURT = "hurt" + RELAXED = "relaxed" + LIVELY = "lively" + WARM = "warm" + CLOSE = "close" + AFFECTIONATE = "affectionate" + + +_OWNER_ONLY_BANDS = frozenset({ExpressionBand.CLOSE, ExpressionBand.AFFECTIONATE}) +_ALL_BANDS = frozenset(ExpressionBand) +_BAND_INDEX = {band: index for index, band in enumerate(ExpressionBand)} +_P4_CAP_BANDS = { + "guarded": ExpressionBand.HURT, + "neutral": ExpressionBand.RELAXED, + "warm": ExpressionBand.WARM, + "close": ExpressionBand.AFFECTIONATE, +} +_DOWN_MOOD_WORDS = frozenset({ + "sad", "bad", "negative", "angry", "anxious", "tense", "tired", "sleepy", + "难过", "低落", "生气", "焦虑", "紧张", "疲惫", "疲劳", "困", "烦", "受伤", "安静", "收声", "困倦", +}) +_UP_MOOD_WORDS = frozenset({ + "happy", "good", "positive", "joy", "calm", + "开心", "高兴", "愉快", "轻松", "积极", "满足", "安心", "兴奋", "顺利", "温柔", "轻快", "明亮", "活跃", "松弛", +}) +EXPRESSION_BAND_LABELS: dict[str, str] = { + ExpressionBand.AVOIDANT.value: "回避", + ExpressionBand.HURT.value: "受伤", + ExpressionBand.RELAXED.value: "放松", + ExpressionBand.LIVELY.value: "活泼", + ExpressionBand.WARM.value: "温暖", + ExpressionBand.CLOSE.value: "亲近", + ExpressionBand.AFFECTIONATE.value: "爱意", +} +COMMON_EXPRESSION_BANDS = tuple(band.value for band in ExpressionBand if band not in _OWNER_ONLY_BANDS) +OWNER_EXPRESSION_BANDS = tuple(band.value for band in ExpressionBand) + + +@dataclass(frozen=True) +class ExpressionDecision: + """A complete, immutable decision consumed by all expression channels.""" + + contract: str + expression_band: str + tone: str + warmth: int + distance: int + address_style: str + response_length: str + followup: bool + initiative: str + proactive_budget: int + tts_style: str + allowed_behaviors: tuple[str, ...] + safety_mode: str + blocker: str | None + reason_codes: tuple[str, ...] + + def to_dict(self) -> dict[str, Any]: + """Return a detached JSON-friendly projection without mutating the DTO.""" + + return asdict(self) + + +@dataclass(frozen=True) +class ExpressionInput: + """Optional typed input form; mappings are also accepted by the builder.""" + + relationship_score: int = 0 + relationship_role: str = "friend" + relationship_mode: str = "" + relationship_baseline: Mapping[str, Any] | None = None + current_interaction: str = "" + bot_state: Mapping[str, Any] | None = None + schedule: Mapping[str, Any] | None = None + message_intent: Mapping[str, Any] | None = None + proactive_candidate: Mapping[str, Any] | None = None + safety_constraints: Mapping[str, Any] | None = None + administrator_override: str | Mapping[str, Any] | None = None + + def to_mapping(self) -> dict[str, Any]: + return { + "relationship_score": self.relationship_score, + "relationship_role": self.relationship_role, + "relationship_mode": self.relationship_mode, + "relationship_baseline": self.relationship_baseline, + "current_interaction": self.current_interaction, + "bot_state": self.bot_state, + "schedule": self.schedule, + "message_intent": self.message_intent, + "proactive_candidate": self.proactive_candidate, + "safety_constraints": self.safety_constraints, + "administrator_override": self.administrator_override, + } + + +_BAND_DETAILS: dict[ExpressionBand, tuple[str, int, int, str, str, str, tuple[str, ...]]] = { + ExpressionBand.AVOIDANT: ("reserved", 15, 90, "formal", "brief", "muted", ("acknowledge", "brief_reply", "give_space")), + ExpressionBand.HURT: ("careful", 28, 78, "reserved", "brief", "soft", ("acknowledge", "brief_reply", "give_space")), + ExpressionBand.RELAXED: ("steady", 48, 55, "neutral", "balanced", "natural", ("reply", "clarify")), + ExpressionBand.LIVELY: ("bright", 63, 40, "casual", "balanced", "bright", ("reply", "light_humor", "followup")), + ExpressionBand.WARM: ("gentle", 76, 28, "warm", "balanced", "warm", ("reply", "support", "followup")), + ExpressionBand.CLOSE: ("intimate", 87, 18, "intimate", "expanded", "intimate", ("reply", "support", "followup", "shared_ritual")), + ExpressionBand.AFFECTIONATE: ("affectionate", 95, 10, "exclusive", "expanded", "affectionate", ("reply", "support", "followup", "shared_ritual", "affectionate_expression")), +} + +_INTERACTION_ALIASES: dict[str, ExpressionBand] = { + "avoidant": ExpressionBand.AVOIDANT, + "backoff": ExpressionBand.AVOIDANT, + "refusing": ExpressionBand.AVOIDANT, + "avoid": ExpressionBand.AVOIDANT, + "hurt": ExpressionBand.HURT, + "injured": ExpressionBand.HURT, + "relaxed": ExpressionBand.RELAXED, + "normal": ExpressionBand.RELAXED, + "steady": ExpressionBand.RELAXED, + "careful": ExpressionBand.RELAXED, + "lively": ExpressionBand.LIVELY, + "active": ExpressionBand.LIVELY, + "warm": ExpressionBand.WARM, + "warming": ExpressionBand.WARM, + "close": ExpressionBand.CLOSE, + "attached": ExpressionBand.CLOSE, + "affectionate": ExpressionBand.AFFECTIONATE, +} + + +def _mapping(value: Any) -> Mapping[str, Any]: + return value if isinstance(value, Mapping) else {} + + +def _text(value: Any) -> str: + return value.strip().lower() if isinstance(value, str) else "" + + +def _flag(value: Any) -> bool: + return value is True or (isinstance(value, int) and not isinstance(value, bool) and value == 1) + + +def _bounded_int(value: Any, default: int, minimum: int, maximum: int) -> int: + if isinstance(value, bool): + return default + if isinstance(value, int): + return max(minimum, min(maximum, value)) + if isinstance(value, float) and value.is_integer(): + return max(minimum, min(maximum, int(value))) + return default + + +def _band(value: Any) -> ExpressionBand | None: + return _INTERACTION_ALIASES.get(_text(value)) + + +def _band_from_interaction(value: Any) -> ExpressionBand | None: + if isinstance(value, Mapping): + for key in ("band", "expression_band", "state", "mode"): + resolved = _band(value.get(key)) + if resolved is not None: + return resolved + return None + return _band(value) + + +def _baseline_band(score: int, *, owner_exclusive: bool = False) -> ExpressionBand: + if owner_exclusive: + return ExpressionBand.CLOSE + if score < -400: + return ExpressionBand.AVOIDANT + if score < 0: + return ExpressionBand.HURT + if score >= 600: + return ExpressionBand.WARM + if score >= 200: + return ExpressionBand.LIVELY + return ExpressionBand.RELAXED + + +def _bounded_text(value: Any, limit: int) -> str: + if not isinstance(value, str): + return "" + return " ".join(value.replace("\r", " ").replace("\n", " ").split())[:limit] + + +def _override_band(value: Any) -> ExpressionBand | None: + if isinstance(value, Mapping): + if value.get("enabled") is False: + return None + return _band_from_interaction(value) + return _band(value) + + +def _has_p4_block(safety: Mapping[str, Any]) -> bool: + if _flag(safety.get("p4_blocked")): + return True + if _text(safety.get("safety_mode")) in {"blocked", "deny", "p4_blocked", "confinement"}: + return True + for key in ("p4", "p4_state"): + state = _mapping(safety.get(key)) + if _flag(state.get("blocked")): + return True + if _text(state.get("confinement_state")) in {"blocked", "active", "confinement"}: + return True + return False + + +def _has_contact_boundary(safety: Mapping[str, Any]) -> bool: + if _flag(safety.get("contact_boundary")) or _flag(safety.get("no_contact")): + return True + boundary = safety.get("contact_boundary") + if _text(boundary) in {"avoid", "no_contact", "stop", "blocked", "quiet"}: + return True + details = _mapping(boundary) + if _flag(details.get("active")) or _flag(details.get("blocked")): + return True + return _text(details.get("mode")) in {"avoid", "no_contact", "stop", "blocked", "quiet"} + + +def _intent_suppresses_followup(intent: Mapping[str, Any]) -> bool: + if intent.get("followup_allowed") is False: + return True + return _text(intent.get("kind")) in {"stop", "end", "no_followup", "quiet"} + + +def _candidate_budget(candidate: Mapping[str, Any]) -> int: + if not _flag(candidate.get("eligible")): + return 0 + for key in ("dynamic_allowance", "daily_allowance", "budget", "max_budget"): + if key in candidate: + return _bounded_int(candidate.get(key), 0, 0, 99) + return 0 + + +def _schedule_is_quiet(schedule: Mapping[str, Any]) -> bool: + if _flag(schedule.get("quiet_hours")) or _flag(schedule.get("do_not_disturb")): + return True + mode = _text(schedule.get("mode")) + if mode in {"quiet", "busy", "rest"}: + return True + text = _mapping_text(schedule, "label", "title", "activity", "schedule") + return any(word in text for word in ("sleep", "busy", "work", "meeting", "class", "commute", "睡", "休息", "忙", "工作", "会议", "上课", "通勤")) + + +def _mapping_text(value: Mapping[str, Any], *keys: str) -> str: + for key in keys: + candidate = value.get(key) + if isinstance(candidate, str): + return candidate.strip().lower()[:240] + return "" + + +def _contains_any(text: str, words: frozenset[str]) -> bool: + return bool(text) and any(word in text for word in words) + + +def _input_mapping(value: Any) -> Mapping[str, Any]: + if isinstance(value, ExpressionInput): + return value.to_mapping() + return _mapping(value) + + +def build_expression_decision(input_data: ExpressionInput | Mapping[str, Any] | None = None, **overrides: Any) -> ExpressionDecision: + """Build one deterministic expression decision from bounded structured inputs. + + Unknown values are ignored rather than echoed. An administrator override + may choose a permitted band, but never bypasses P4 or contact boundaries. + """ + + source = dict(_input_mapping(input_data)) + source.update(overrides) + reasons: list[str] = [] + safety = _mapping(source.get("safety_constraints")) + role = _text(source.get("relationship_role")) + mode = _text(source.get("relationship_mode")) + owner_account = role == "owner" + owner_exclusive = owner_account and mode == "owner_exclusive" + + if _has_p4_block(safety): + return _blocked_decision("p4_blocked", "p4_safety", reasons) + contact_boundary = _has_contact_boundary(safety) + passive_reengagement = _flag(safety.get("passive_reengagement")) + if contact_boundary and not passive_reengagement: + return _blocked_decision("contact_boundary", "contact_boundary", reasons) + + score = _bounded_int(source.get("relationship_score"), 0, -1200, 1200) + relationship_baseline = _mapping(source.get("relationship_baseline")) + band = _baseline_band(score, owner_exclusive=owner_exclusive) + interaction_band = _band_from_interaction(source.get("current_interaction")) + if interaction_band is not None: + if interaction_band == ExpressionBand.RELAXED: + if band != ExpressionBand.RELAXED: + reasons.append("relationship_baseline_retained") + else: + band = interaction_band + reasons.append("interaction_band_applied") + + override_band = _override_band(source.get("administrator_override")) + if override_band is not None: + band = override_band + reasons.append("administrator_override_applied") + + if band in _OWNER_ONLY_BANDS and not owner_account: + band = ExpressionBand.WARM + reasons.append("owner_role_required") + if contact_boundary: + band = ExpressionBand.AVOIDANT + reasons.append("contact_boundary_passive_reengagement") + p4_cap = _P4_CAP_BANDS.get(_text(safety.get("p4_warmth_cap"))) + if p4_cap is not None and _BAND_INDEX[band] > _BAND_INDEX[p4_cap]: + band = p4_cap + reasons.append("p4_warmth_cap_applied") + + tone, warmth, distance, address_style, response_length, tts_style, behaviors = _BAND_DETAILS[band] + baseline_tone = _bounded_text(relationship_baseline.get("tone"), 120) + baseline_address = _bounded_text( + relationship_baseline.get("address_style") or relationship_baseline.get("address_level"), + 100, + ) + if band not in {ExpressionBand.AVOIDANT, ExpressionBand.HURT}: + if baseline_tone: + tone = baseline_tone + reasons.append("relationship_tone_applied") + if baseline_address: + address_style = baseline_address + reasons.append("relationship_address_applied") + soft_behaviors = _mapping(relationship_baseline.get("soft_behaviors")) + if soft_behaviors: + if soft_behaviors.get("allow_followup") is False: + behaviors = tuple(item for item in behaviors if item != "followup") + reasons.append("relationship_followup_cap") + if soft_behaviors.get("allow_playful_jokes") is False: + behaviors = tuple(item for item in behaviors if item != "light_humor") + if soft_behaviors.get("allow_memory_mention") is False: + behaviors = tuple(item for item in behaviors if item != "shared_ritual") + if soft_behaviors.get("allow_daily_care") is False: + behaviors = tuple(item for item in behaviors if item != "support") + intent = _mapping(source.get("message_intent")) + followup = "followup" in behaviors and not _intent_suppresses_followup(intent) + if not followup and "followup" in behaviors: + reasons.append("intent_followup_suppressed") + + bot_state = _mapping(source.get("bot_state")) + energy = _bounded_int(bot_state.get("energy"), 70, 0, 100) + mood = _mapping_text(bot_state, "mood", "mood_bias", "label", "state") + low_energy = energy < 30 + down_mood = _contains_any(mood, _DOWN_MOOD_WORDS) + up_mood = _contains_any(mood, _UP_MOOD_WORDS) + if low_energy: + response_length = "brief" if response_length != "brief" else response_length + followup = False + warmth = max(0, warmth - 10) + distance = min(100, distance + 8) + tts_style = "soft" + reasons.append("low_energy_expression_cap") + if down_mood: + followup = False + warmth = max(0, warmth - 8) + distance = min(100, distance + 6) + if tone not in {"reserved", "careful"}: + tone = "gentle" + tts_style = "soft" + reasons.append("down_mood_expression_cap") + elif up_mood and not low_energy: + warmth = min(100, warmth + 5) + reasons.append("up_mood_expression_lift") + + schedule = _mapping(source.get("schedule")) + budget = _candidate_budget(_mapping(source.get("proactive_candidate"))) + if "proactive_care_limit" in relationship_baseline: + stage_budget = _bounded_int(relationship_baseline.get("proactive_care_limit"), 0, 0, 30) + if budget > stage_budget: + budget = stage_budget + reasons.append("relationship_proactive_cap") + initiative = "allowed" if budget else "passive_only" + if band in {ExpressionBand.AVOIDANT, ExpressionBand.HURT}: + budget = 0 + initiative = "passive_only" + reasons.append("interaction_proactive_suppressed") + if _schedule_is_quiet(schedule): + budget = 0 + initiative = "passive_only" + response_length = "brief" if response_length != "brief" else response_length + followup = False + warmth = max(0, warmth - 6) + distance = min(100, distance + 4) + reasons.append("schedule_proactive_suppressed") + + if not followup and "followup" in behaviors: + behaviors = tuple(item for item in behaviors if item != "followup") + + return ExpressionDecision( + contract=EXPRESSION_CONTRACT_VERSION, + expression_band=band.value, + tone=tone, + warmth=warmth, + distance=distance, + address_style=address_style, + response_length=response_length, + followup=followup, + initiative=initiative, + proactive_budget=budget, + tts_style=tts_style, + allowed_behaviors=behaviors, + safety_mode="contact_boundary_passive" if contact_boundary else "normal", + blocker=None, + reason_codes=tuple(reasons), + ) + + +def allowed_expression_bands(relationship_role: Any, relationship_mode: Any) -> tuple[str, ...]: + role = _text(relationship_role) + del relationship_mode + return OWNER_EXPRESSION_BANDS if role == "owner" else COMMON_EXPRESSION_BANDS + + +def current_interaction_projection( + value: Any, + *, + relationship_role: Any = "friend", + relationship_mode: Any = "normal", + now: Any = None, +) -> dict[str, Any]: + """Normalize persisted and legacy interaction state for runtime/page use.""" + raw = dict(value) if isinstance(value, Mapping) else {} + band = _band_from_interaction(raw) or ExpressionBand.RELAXED + allowed = allowed_expression_bands(relationship_role, relationship_mode) + reason_codes: list[str] = [] + if band.value not in allowed: + band = ExpressionBand.WARM + reason_codes.append("owner_role_required") + expires_at = _bounded_timestamp(raw.get("expires_at")) + current_ts = _bounded_timestamp(now) + manual = bool(raw.get("manual_override") or _text(raw.get("source")) == "manual") + if expires_at and current_ts and current_ts >= expires_at: + band = ExpressionBand.RELAXED + manual = False + reason_codes.append("interaction_expired") + source = "manual" if manual else _text(raw.get("source")) or "automatic" + reason = str(raw.get("reason") or raw.get("reason_code") or "").replace("\r", " ").replace("\n", " ")[:120] + return { + "expression_band": band.value, + "label": EXPRESSION_BAND_LABELS[band.value], + "source": source, + "operator": _bounded_text(raw.get("operator"), 40), + "reason": reason, + "updated_at": _bounded_timestamp(raw.get("updated_at")), + "expires_at": expires_at, + "manual_override": manual, + "allowed_bands": list(allowed), + "reason_codes": reason_codes, + } + + +def expression_decision_prompt(value: ExpressionDecision | Mapping[str, Any]) -> str: + decision = value.to_dict() if isinstance(value, ExpressionDecision) else dict(_mapping(value)) + band = _band(decision.get("expression_band")) or ExpressionBand.RELAXED + if decision.get("blocker"): + return "当前表达受边界或安全规则限制:保持简短、低压,不主动扩展或追问。" + followup = "可以自然追问" if bool(decision.get("followup")) else "不要追问" + initiative = "允许在合适窗口主动联系" if decision.get("initiative") == "allowed" else "本轮只被动回应" + return ( + f"当前互动表达:{EXPRESSION_BAND_LABELS[band.value]};" + f"语气={str(decision.get('tone') or 'steady')[:24]}," + f"称呼距离={str(decision.get('address_style') or 'neutral')[:24]}," + f"回复长度={str(decision.get('response_length') or 'balanced')[:24]};" + f"{followup};{initiative}。" + ) + + +def _bounded_timestamp(value: Any) -> float: + if isinstance(value, bool) or not isinstance(value, (int, float)): + return 0.0 + numeric = float(value) + return numeric if 0 < numeric < 10**12 else 0.0 + + +def _blocked_decision(reason: str, blocker: str, inherited_reasons: list[str]) -> ExpressionDecision: + return ExpressionDecision( + contract=EXPRESSION_CONTRACT_VERSION, + expression_band=ExpressionBand.AVOIDANT.value, + tone="blocked", + warmth=0, + distance=100, + address_style="none", + response_length="none", + followup=False, + initiative="blocked", + proactive_budget=0, + tts_style="none", + allowed_behaviors=(), + safety_mode=reason, + blocker=blocker, + reason_codes=tuple(inherited_reasons + [reason]), + ) + + +# A descriptive alias keeps runtime call sites readable while preserving one contract. +resolve_expression_decision = build_expression_decision + + +__all__ = [ + "COMMON_EXPRESSION_BANDS", + "EXPRESSION_CONTRACT_VERSION", + "EXPRESSION_BAND_LABELS", + "ExpressionBand", + "ExpressionDecision", + "ExpressionInput", + "OWNER_EXPRESSION_BANDS", + "allowed_expression_bands", + "build_expression_decision", + "current_interaction_projection", + "expression_decision_prompt", + "resolve_expression_decision", +] diff --git a/constants.py b/constants.py index fb5b74c..29fa960 100644 --- a/constants.py +++ b/constants.py @@ -382,6 +382,13 @@ _DEFAULT_USER_TEMPLATE = { "auto_profile_created_at": 0, "profile_origin": "", "relationship_role": "", + "relationship_mode": "normal", + "relationship_ledger": [], + "relationship_daily_totals": {}, + "relationship_last_effective_at": 0, + "relationship_decay_settled_day": "", + "relationship_last_decay_stage_drop_at": 0, + "current_interaction": {}, "proactive_daily_limit": -1, "proactive_idle_minutes": -1, "proactive_min_interval_minutes": -1, @@ -415,11 +422,9 @@ _DEFAULT_USER_TEMPLATE = { "reply_count": 0, "action_reply_affinity": {}, "relationship_score": 0, - "persona_relationship": {}, "companion_memory": {}, "expression_profile": {}, "intent_profile": {}, - "relationship_state": {}, "recent_reply_topics": [], "postprocess_stats": {}, "dialogue_episodes": [], diff --git a/core_store.py b/core_store.py index fed3924..7166c86 100644 --- a/core_store.py +++ b/core_store.py @@ -115,6 +115,7 @@ from .helpers import ( _today_key, ) from .relationship_policy import RELATIONSHIP_SCORE_MAX, RELATIONSHIP_SCORE_MIN +from .relationship_ledger import apply_natural_relationship_decay, normalize_relationship_mode from .config_migration import _ensure_config_parent_dir from .storage.store_manager import StoreManager from .person_context_contract import empty_person_store, ensure_person_store @@ -1298,6 +1299,26 @@ class CoreStoreMixin: if key not in user: user[key] = deepcopy(default_value) self._ensure_private_user_role(user_id, user) + user["relationship_mode"] = normalize_relationship_mode( + user.get("relationship_mode"), + user.get("relationship_role"), + ) + decay_result = apply_natural_relationship_decay( + user, + policy=( + getattr(self, "relationship_stage_policy", None) + if bool(getattr(self, "enable_custom_relationship_stage_policy", False)) + else None + ), + grace_days=int(getattr(self, "relationship_decay_grace_days", 3)), + early_rate=int(getattr(self, "relationship_decay_early_per_day", 2)), + middle_rate=int(getattr(self, "relationship_decay_middle_per_day", 5)), + late_rate=int(getattr(self, "relationship_decay_late_per_day", 8)), + ) + if decay_result.get("changed"): + save_scheduler = getattr(self, "_schedule_data_save", None) + if callable(save_scheduler): + save_scheduler() user.setdefault("manual_enabled", False) user.setdefault("manual_disabled", False) if ( @@ -1347,6 +1368,97 @@ class CoreStoreMixin: return observed return fixed or _single_line(user_id, 24) + def _merge_group_observation_into_private_user( + self, + user_id: str, + user: dict[str, Any], + *, + now: float, + use_observed_name: bool = False, + ) -> bool: + """Merge exact QQ observation metadata without importing group content.""" + finder = getattr(self, "_worldbook_group_observation_profile_by_identity", None) + observed = finder(user_id) if callable(finder) else None + if not ( + isinstance(observed, tuple) + and len(observed) == 2 + and isinstance(observed[1], dict) + and bool(observed[1].get("observation_only")) + ): + return False + profile_id, profile = observed + changed = False + observed_name = _single_line(profile.get("name"), 40) + if use_observed_name and observed_name and user.get("nickname") != observed_name: + user["nickname"] = observed_name + changed = True + + source_names = user.setdefault("group_observation_names", []) + if not isinstance(source_names, list): + source_names = [] + user["group_observation_names"] = source_names + changed = True + if observed_name and observed_name not in source_names: + source_names.append(observed_name) + del source_names[:-16] + changed = True + + source_scopes = profile.get("group_observation_scope_ids") + scopes = user.setdefault("group_observation_scope_ids", []) + if not isinstance(scopes, list): + scopes = [] + user["group_observation_scope_ids"] = scopes + changed = True + for raw_scope in source_scopes if isinstance(source_scopes, list) else []: + scope = _single_line(raw_scope, 80) + if scope and scope not in scopes: + scopes.append(scope) + changed = True + del scopes[:-32] + + source_aliases = profile.get("group_aliases") + aliases = user.setdefault("group_observation_aliases", {}) + if not isinstance(aliases, dict): + aliases = {} + user["group_observation_aliases"] = aliases + changed = True + if isinstance(source_aliases, dict): + for raw_group_id, raw_names in source_aliases.items(): + group_id = _single_line(raw_group_id, 80) + if not group_id: + continue + current = aliases.setdefault(group_id, []) + if not isinstance(current, list): + current = [] + aliases[group_id] = current + changed = True + for raw_name in raw_names if isinstance(raw_names, list) else []: + name = _single_line(raw_name, 40) + if name and name not in current: + current.append(name) + changed = True + del current[:-8] + + sources = user.setdefault("profile_sources", []) + if not isinstance(sources, list): + sources = [] + user["profile_sources"] = sources + changed = True + for source in ("private_chat", "group_observation"): + if source not in sources: + sources.append(source) + changed = True + marker = str(profile_id or user_id) + if profile.get("private_profile_merged") is not True or profile.get("private_user_id") != user_id: + profile["private_profile_merged"] = True + profile["private_user_id"] = user_id + profile["private_profile_merged_at"] = now + profile["private_profile_merge_source_id"] = marker + changed = True + if changed: + user["group_observation_merged_at"] = now + return changed + def _ensure_auto_private_user_profile( self, event: Any, @@ -1356,8 +1468,6 @@ class CoreStoreMixin: now: float | None = None, ) -> tuple[dict[str, Any] | None, bool]: """Create a minimal private profile without granting implicit authority.""" - if not bool(getattr(self, "enable_auto_user_profile_creation", True)): - return None, False canonical_user_id = self._canonical_private_user_id(str(user_id or "").strip()) if not canonical_user_id or self._is_bot_self_user_id(canonical_user_id): return None, False @@ -1367,7 +1477,16 @@ class CoreStoreMixin: users = self.data.setdefault("users", {}) existing = users.get(canonical_user_id) if isinstance(users, dict) else None if isinstance(existing, dict): + observation_merger = getattr(self, "_merge_group_observation_into_private_user", None) + if callable(observation_merger) and observation_merger( + canonical_user_id, + existing, + now=float(now if now is not None else _now_ts()), + ): + self._schedule_data_save() return existing, False + if not bool(getattr(self, "enable_auto_user_profile_creation", True)): + return None, False user = self._get_user(canonical_user_id) created_at = float(now if now is not None else _now_ts()) @@ -1375,12 +1494,29 @@ class CoreStoreMixin: user["auto_profile_created_at"] = created_at user["profile_origin"] = "private_auto" user["relationship_role"] = "friend" + user["relationship_mode"] = "normal" user["relationship_score"] = max( RELATIONSHIP_SCORE_MIN, min(RELATIONSHIP_SCORE_MAX, _safe_int(getattr(self, "default_relationship_score", 0), 0)), ) user["nickname"] = self._auto_profile_nickname(canonical_user_id, sender_display_name) + observation_merger = getattr(self, "_merge_group_observation_into_private_user", None) + if callable(observation_merger): + observation_merger( + canonical_user_id, + user, + now=created_at, + use_observed_name=not bool(_single_line(sender_display_name, 40)), + ) user["style"] = _single_line(getattr(self, "default_style", "温柔"), 24) or "温柔" + user["current_interaction"] = { + "expression_band": str(getattr(self, "default_interaction_band", "relaxed") or "relaxed"), + "source": "default_profile", + "reason": "auto_profile_default", + "updated_at": created_at, + "expires_at": 0, + "manual_override": False, + } auto_enabled = bool(getattr(self, "auto_enable_companion_for_new_users", False)) user["auto_enabled"] = auto_enabled user["manual_enabled"] = False diff --git a/daily_state.py b/daily_state.py index e6fcb81..35cb537 100644 --- a/daily_state.py +++ b/daily_state.py @@ -15943,10 +15943,6 @@ class DailyStateMixin: } if memory_companion_proactive_payload: await self._memory_companion_record_proactive_message(**memory_companion_proactive_payload) - self._create_lifecycle_background_task( - self._refresh_persona_relationship(user_id, current_snapshot, trigger="proactive"), - label="refresh_persona_relationship_proactive", - ) await self._run_proactive_maintenance_tasks() async with self._data_lock: diff --git a/group_observation.py b/group_observation.py index 2738c85..b8ea39d 100644 --- a/group_observation.py +++ b/group_observation.py @@ -316,6 +316,29 @@ _GROUP_INJECTION_QUOTE_DAMPENERS = ( class GroupObservationMixin: """群聊观察""" + def _record_group_observation_profile_projection_result(self, code: str) -> None: + """Keep aggregate-only E2A observability without retaining message data. + + The counters are intentionally not keyed by group, sender, message id, + or text. They help distinguish a disabled route from an unexpected + projection failure while preserving the observation-only boundary. + """ + result_code = _single_line(code, 48) or "unknown" + data = getattr(self, "data", None) + if not isinstance(data, dict): + return + stats = data.setdefault("group_observation_profile_projection_stats", {}) + if not isinstance(stats, dict): + stats = {} + data["group_observation_profile_projection_stats"] = stats + counts = stats.setdefault("counts", {}) + if not isinstance(counts, dict): + counts = {} + stats["counts"] = counts + counts[result_code] = _safe_int(counts.get(result_code), 0, 0) + 1 + stats["last_result_code"] = result_code + stats["last_result_at"] = _now_ts() + def _group_injection_guard_threshold(self) -> int: return _GROUP_INJECTION_GUARD_THRESHOLD @@ -669,16 +692,46 @@ class GroupObservationMixin: qq_nickname = _single_line(nickname_getter(event), 40) except Exception: qq_nickname = "" - if self.enable_group_member_profiles: + projection_result = "skipped_member_profiles_disabled" + effective_group_id = str(group_id or group.get("group_id") or "") + group_enabled_getter = getattr(self, "_group_enabled_for_event", None) + group_allowed = True + if callable(group_enabled_getter): + try: + group_allowed = bool(group_enabled_getter(effective_group_id)) + except Exception: + group_allowed = False + if not group_allowed: + projection_result = "skipped_group_not_allowed" + elif not _single_line(sender_id, 40): + projection_result = "skipped_missing_sender" + elif bool(getattr(self, "enable_group_member_profiles", False)): profile_ensurer = getattr(self, "_ensure_worldbook_group_observation_profile", None) - if callable(profile_ensurer): - profile_ensurer( - group_id=str(group_id or group.get("group_id") or ""), - sender_id=sender_id, - qq_nickname=qq_nickname, - group_card=sender_name, - now=now, - ) + if not callable(profile_ensurer): + projection_result = "skipped_profile_handler_unavailable" + else: + profiles = self.data.get("worldbook_member_profiles") if isinstance(getattr(self, "data", None), dict) else {} + existed = isinstance(profiles, dict) and isinstance(profiles.get(str(sender_id)), dict) + try: + profile = profile_ensurer( + group_id=effective_group_id, + sender_id=sender_id, + qq_nickname=qq_nickname, + group_card=sender_name, + now=now, + ) + if not isinstance(profile, dict): + projection_result = "skipped_invalid_identity" + elif bool(profile.get("observation_only")): + projection_result = "updated" if existed else "created" + else: + projection_result = "skipped_existing_authoritative_profile" + except Exception: + # Profile projection must never block an otherwise valid + # whitelisted-group observation or its reply path. + projection_result = "failed" + logger.warning("[PrivateCompanion] 群观察档案投影失败: code=failed") + self._record_group_observation_profile_projection_result(projection_result) recent = group.setdefault("recent_messages", []) if not isinstance(recent, list): @@ -904,6 +957,7 @@ class GroupObservationMixin: cleaned = _single_line(text, 260) clean_message_id = _single_line(message_id, 120) if not cleaned: + self._record_group_observation_profile_projection_result("skipped_empty_message") return False marker = getattr(event, "private_companion_group_observation_capture", None) if event is not None else None already_captured = self._group_observation_marker_matches( diff --git a/main.py b/main.py index 12148e0..658d220 100644 --- a/main.py +++ b/main.py @@ -136,11 +136,9 @@ from .person_context_contract import ( from .unified_person_registry import UnifiedPersonRegistry from .context_orchestration import build_context, project_context from .p4_shadow import build_p4_shadow -from .p4_affinity_confinement import apply_legacy_relationship_delta from .p4_live_runtime import decide_live_request from .p4_runtime_gate import SAFE_CONFINEMENT_REPLY from .p6_readonly_projection import build_p6_readonly_status -from .reply_temperature import compose_reply_temperature from .plugin_identity import ( PLUGIN_ID, PLUGIN_VERSION, @@ -149,6 +147,8 @@ from .plugin_identity import ( ) from .runtime_compat import probe_runtime_capabilities from .relationship_policy import normalize_relationship_stage_policy +from .relationship_ledger import apply_relationship_event +from .companion_interaction_expression import build_expression_decision, expression_decision_prompt from .user_rest_gate import UserRestGateMixin from .busy_reply_gate import BusyReplyGateMixin from .memory_companion_adapter import MemoryCompanionAdapterMixin @@ -1439,6 +1439,9 @@ class PrivateCompanionPlugin( self.default_nickname_strategy = "platform_display_name" self.default_relationship_role = "friend" self.default_relationship_score = self._cfg_int(c, "default_relationship_score", 0, -1200, 1200) + self.default_interaction_band = self._cfg_str(c, "default_interaction_band", "relaxed") + if self.default_interaction_band not in {"avoidant", "hurt", "relaxed", "lively", "warm"}: + self.default_interaction_band = "relaxed" self.default_proactive_enabled = self._cfg_bool(c, "default_proactive_enabled", False) self.default_proactive_daily_limit = self._cfg_int(c, "default_proactive_daily_limit", 0, 0, 30) self.enable_custom_relationship_stage_policy = self._cfg_bool( @@ -1449,6 +1452,18 @@ class PrivateCompanionPlugin( self.relationship_stage_policy = normalize_relationship_stage_policy( self._cfg_raw(c, "relationship_stage_policy", []) ) + self.owner_exclusive_label = self._cfg_str(c, "owner_exclusive_label", "专属联结", "专属联结") + self.owner_exclusive_tone = self._cfg_str(c, "owner_exclusive_tone", "温暖、亲近、稳定", "温暖、亲近、稳定") + self.owner_exclusive_address_style = self._cfg_str(c, "owner_exclusive_address_style", "优先使用已确认的专属称呼", "优先使用已确认的专属称呼") + self.owner_exclusive_proactive_limit = self._cfg_int(c, "owner_exclusive_proactive_limit", 6, 0, 30) + self.relationship_event_window_minutes = self._cfg_int(c, "relationship_event_window_minutes", 30, 1, 1440) + self.relationship_positive_event_cap = self._cfg_int(c, "relationship_positive_event_cap", 4, 1, 30) + self.relationship_negative_event_cap = self._cfg_int(c, "relationship_negative_event_cap", 12, 1, 60) + self.relationship_positive_daily_cap = self._cfg_int(c, "relationship_positive_daily_cap", 12, 0, 120) + self.relationship_decay_grace_days = self._cfg_int(c, "relationship_decay_grace_days", 3, 0, 30) + self.relationship_decay_early_per_day = self._cfg_int(c, "relationship_decay_early_per_day", 2, 0, 30) + self.relationship_decay_middle_per_day = self._cfg_int(c, "relationship_decay_middle_per_day", 5, 0, 30) + self.relationship_decay_late_per_day = self._cfg_int(c, "relationship_decay_late_per_day", 8, 0, 30) self.require_private_opt_in = self._cfg_bool(c, "require_private_opt_in", True) self.target_user_ids = self._cfg_raw(c, "target_user_ids", []) self.private_user_aliases = self._parse_private_user_aliases(self._cfg_raw(c, "private_user_aliases", "")) @@ -2014,7 +2029,9 @@ class PrivateCompanionPlugin( self.proactive_review_low_score_threshold = self._cfg_unit_interval(c, "proactive_review_low_score_threshold", 0.34, 0.0) self.proactive_review_pressure_threshold = self._cfg_unit_interval(c, "proactive_review_pressure_threshold", 0.55, 0.0) self.enable_passive_topic_suppression = self._cfg_bool(c, "enable_passive_topic_suppression", True) - self.enable_relationship_analysis = self._cfg_bool(c, "enable_relationship_analysis", True) + # Compatibility flag only: the old model-generated three-band + # relationship analysis is retired by the unified expression system. + self.enable_relationship_analysis = False self.enable_relationship_state_machine = self._cfg_bool(c, "enable_relationship_state_machine", True) self.enable_emotion_simulation = self._cfg_bool(c, "enable_emotion_simulation", True) self.enable_llm_emotion_judgement = self._cfg_bool(c, "enable_llm_emotion_judgement", False) @@ -2562,12 +2579,18 @@ class PrivateCompanionPlugin( return self.unified_person_registry.read_p4_live_state(person_id) def _p4_b_apply_legacy_relationship_delta(self, user: dict[str, Any], delta: int, *, reason_code: str = "") -> bool: - del reason_code - return apply_legacy_relationship_delta( + if bool(getattr(self, "enable_p4_b_legacy_score_isolation", False)): + return False + result = apply_relationship_event( user, delta, - isolate=bool(getattr(self, "enable_p4_b_legacy_score_isolation", False)), + reason_code=reason_code or "legacy_relationship_event", + positive_daily_cap=int(getattr(self, "relationship_positive_daily_cap", 12)), + event_window_seconds=int(getattr(self, "relationship_event_window_minutes", 30)) * 60, + positive_event_cap=int(getattr(self, "relationship_positive_event_cap", 4)), + negative_event_cap=int(getattr(self, "relationship_negative_event_cap", 12)), ) + return bool(result.get("changed")) def _p4_live_state_for_event(self, event: Any) -> dict[str, Any] | None: try: @@ -2586,8 +2609,8 @@ class PrivateCompanionPlugin( return {"_p4_live_invalid": True} return result.get("state") - def _bounded_p4_reply_temperature_signals(self, event: Any) -> dict[str, Any]: - """Return transient, bounded advisory inputs for the P4 reply projection.""" + def _bounded_expression_state_signals(self, event: Any) -> dict[str, Any]: + """Return transient, bounded Bot-state inputs for the unified expression decision.""" data = getattr(self, "data", None) daily_state = data.get("daily_state") if isinstance(data, dict) else None energy = daily_state.get("energy") if isinstance(daily_state, dict) else None @@ -9395,8 +9418,6 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge return state = self._p4_live_state_for_event(event) decision = decide_live_request(state) - if decision.get("decision") == "skip": - return if decision.get("decision") == "block": # This runs before P5/Memory and the enrichment collectors. Leave # no request route to original prompt, tool, bridge, or context data. @@ -9422,17 +9443,44 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge await self._reply(event, SAFE_CONFINEMENT_REPLY) event.stop_event() return - temperature = compose_reply_temperature( - decision.get("warmth_projection", {}).get("tier"), - **self._bounded_p4_reply_temperature_signals(event), - ) + p4_cap = _single_line(decision.get("warmth_projection", {}).get("tier"), 24) if decision.get("decision") != "skip" else "" + transient = self._bounded_expression_state_signals(event) + expression_projection: dict[str, Any] = {} try: - setattr(req, "_private_companion_reply_temperature", temperature) + sender_id = self._canonical_private_user_id(str(event.get_sender_id())) + except Exception: + sender_id = "" + users = self.data.get("users", {}) if isinstance(getattr(self, "data", None), dict) else {} + current_user = users.get(sender_id) if sender_id and isinstance(users, dict) else None + expression_builder = getattr(self, "_build_expression_decision_for_user", None) + if isinstance(current_user, dict) and callable(expression_builder): + try: + expression = expression_builder( + current_user, + safety_constraints={"p4_warmth_cap": p4_cap} if p4_cap else {}, + passive_reengagement=True, + bot_state={"energy": transient.get("energy"), "mood": transient.get("mood")}, + schedule={"label": transient.get("schedule") or ""}, + ) + expression_projection = expression.to_dict() if hasattr(expression, "to_dict") else dict(expression or {}) + except Exception as exc: + logger.debug("[PrivateCompanion] 统一表达决策生成失败,使用保守默认值: %s", _single_line(exc, 120)) + if not expression_projection: + fallback = build_expression_decision( + { + "bot_state": {"energy": transient.get("energy"), "mood": transient.get("mood")}, + "schedule": {"label": transient.get("schedule") or ""}, + "safety_constraints": {"p4_warmth_cap": p4_cap} if p4_cap else {}, + } + ) + expression_projection = fallback.to_dict() + try: + setattr(req, "_private_companion_expression_decision", expression_projection) except Exception: pass - instruction = _single_line(temperature.get("instruction"), 240) + instruction = expression_decision_prompt(expression_projection) if instruction and hasattr(req, "system_prompt"): - req.system_prompt = f"{str(getattr(req, 'system_prompt', '') or '').rstrip()}\n\n[Reply boundary]\n{instruction}" + req.system_prompt = f"{str(getattr(req, 'system_prompt', '') or '').rstrip()}\n\n[Companion expression]\n{instruction}" @filter.on_llm_request(priority=-22000) async def prepare_p5_memory_attestation(self, event: AstrMessageEvent, req: ProviderRequest, *args, **kwargs): @@ -12676,10 +12724,6 @@ wakeup_type={_single_line(wakeup.get('type'), 40)} score={_single_line(wakeup.ge elif is_target_user: pass if is_target_user: - self._create_lifecycle_background_task( - self._refresh_persona_relationship(user_id, user_snapshot, trigger="inbound"), - label="refresh_persona_relationship_inbound", - ) self._create_lifecycle_background_task( self._maybe_refresh_companion_memory(user_id, user_snapshot), label="refresh_companion_memory_inbound", diff --git a/memory_companion_adapter.py b/memory_companion_adapter.py index 8922d54..bab1cf3 100644 --- a/memory_companion_adapter.py +++ b/memory_companion_adapter.py @@ -23,6 +23,8 @@ from .bot_personal_contract import ( ) from .bot_personal_outbox import BotPersonalOutbox from .helpers import _missing_optional_model_dependency, _path_text, _safe_float, _safe_int, _single_line +from .companion_interaction_expression import current_interaction_projection +from .relationship_ledger import normalize_relationship_mode from .relationship_policy import relationship_projection_for_bridge @@ -1469,6 +1471,19 @@ class MemoryCompanionAdapterMixin: else None ) projection = relationship_projection_for_bridge(user.get("relationship_score", 0), policy) + role_getter = getattr(self, "_private_user_role", None) + try: + role = role_getter(user, user_id) if callable(role_getter) else str(user.get("relationship_role") or "friend") + except Exception: + role = str(user.get("relationship_role") or "friend") + relationship_mode = normalize_relationship_mode(user.get("relationship_mode"), role) + projection["relationship_mode"] = relationship_mode + projection["current_interaction"] = current_interaction_projection( + user.get("current_interaction"), + relationship_role=role, + relationship_mode=relationship_mode, + now=time.time(), + ) bridge = self._memory_companion_bridge() consumer = getattr(bridge, "consume_relationship_projection", None) if bridge is not None else None if callable(consumer): diff --git a/page_api.py b/page_api.py index 7689b21..b7ff8cd 100644 --- a/page_api.py +++ b/page_api.py @@ -29,7 +29,9 @@ from .constants import DEFAULT_DAILY_PLAN_ITEMS, PAGE_FONT_NAMES, PAGE_THEME_NAM from .config_migration import _ensure_config_parent_dir from .diagnostic_envelope import DIAGNOSTIC_ENVELOPE_VERSION, diagnostic_test_id, normalize_diagnostic_result from .helpers import _flat_get, _normalize_timezone_name, _path_text, _redact_outbound_secrets, _safe_int, _set_into_config, _set_today_key_timezone, _strip_internal_message_blocks, _text_looks_garbled, _text_similarity, _today_key +from .companion_interaction_expression import current_interaction_projection from .reference_asset_gate import ReferenceAssetGate +from .relationship_ledger import normalize_relationship_mode, relationship_ledger_summary from .relationship_policy import ( normalize_relationship_stage_policy, relationship_stage_for_score, @@ -181,6 +183,51 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio reply_band = "low" relationship_intimacy = self._relationship_intimacy_projection(self._int(user.get("relationship_score"))) + role = self.plugin._private_user_role(user, str(user.get("user_id") or "")) if hasattr(self.plugin, "_private_user_role") else str(user.get("relationship_role") or "friend") + relationship_mode = normalize_relationship_mode(user.get("relationship_mode"), role) + relationship_changes = relationship_ledger_summary(user) + relationship_intimacy["trend"] = relationship_changes.get("trend", "steady") + relationship_intimacy["recent_delta"] = relationship_changes.get("recent_delta", 0) + current_interaction = current_interaction_projection( + user.get("current_interaction"), + relationship_role=role, + relationship_mode=relationship_mode, + now=time.time(), + ) + expression_projection = { + "contract": "companion_interaction_expression.v1", + "status": "configured_projection", + "expression_band": current_interaction.get("expression_band") or "relaxed", + "tone": "steady", + "response_length": "balanced", + "initiative": "passive_only", + "safety_mode": "live_event_not_evaluated", + "blocker": "", + "reason_codes": [], + } + expression_builder = getattr(self.plugin, "_build_expression_decision_for_user", None) + if callable(expression_builder): + try: + raw_expression = expression_builder(user, passive_reengagement=True) + raw_projection = raw_expression.to_dict() if hasattr(raw_expression, "to_dict") else dict(raw_expression or {}) + expression_projection.update( + { + "contract": self._single_line(raw_projection.get("contract"), 80) or "companion_interaction_expression.v1", + "expression_band": self._single_line(raw_projection.get("expression_band"), 24) or "relaxed", + "tone": self._single_line(raw_projection.get("tone"), 24) or "steady", + "response_length": self._single_line(raw_projection.get("response_length"), 24) or "balanced", + "initiative": self._single_line(raw_projection.get("initiative"), 24) or "passive_only", + "safety_mode": self._single_line(raw_projection.get("safety_mode"), 40) or "normal", + "blocker": self._single_line(raw_projection.get("blocker"), 40), + "reason_codes": [ + self._single_line(code, 48) + for code in list(raw_projection.get("reason_codes") or [])[:8] + if self._single_line(code, 48) + ], + } + ) + except Exception: + pass memory_phase = {"status": "unavailable", "phase": "unknown", "momentum_band": "unknown"} getter = getattr(self.plugin, "_memory_companion_peek_relationship_phase", None) session_id = self._single_line(user.get("umo"), 200) @@ -208,11 +255,14 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "band": relationship_intimacy["phase"]["label"], }, "relationship_stage": self._single_line(relationship_stage, 24) or "unclassified", + "relationship_mode": relationship_mode, "relationship_intimacy": relationship_intimacy, + "relationship_changes": relationship_changes, + "current_interaction": current_interaction, "interaction": {"inbound_count": inbound, "reply_count": replies, "reply_band": reply_band}, "memory_phase": memory_phase, "network": network, - "reply_temperature": {"status": "live_chat_only"}, + "expression_decision": expression_projection, } def _create_page_background_task(self, operation: Any, *, label: str) -> asyncio.Task | None: @@ -9836,31 +9886,6 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio ) relationship_stage = "" rel_state = user.get("relationship_state") if isinstance(user.get("relationship_state"), dict) else {} - if isinstance(rel_state, dict): - relationship_stage = self._single_line(rel_state.get("stage"), 12) - profile_getter = getattr(self.plugin, "_relationship_profile", None) - if not relationship_stage and callable(profile_getter): - try: - profile = profile_getter(user) - if isinstance(profile, dict): - relationship_stage = self._single_line(profile.get("level"), 12) - except Exception: - relationship_stage = "" - if relationship_stage not in {"亲近", "熟悉", "陌生"}: - persona_profile = user.get("persona_relationship") if isinstance(user.get("persona_relationship"), dict) else {} - relationship_stage = self._single_line(persona_profile.get("level"), 12) if isinstance(persona_profile, dict) else "" - if relationship_stage not in {"亲近", "熟悉", "陌生"}: - score = self._int(user.get("relationship_score")) - inbound_count = self._int(user.get("inbound_count")) - proactive_count = self._int(user.get("proactive_sent_count")) - reply_count = self._int(user.get("reply_count")) - reply_rate = reply_count / proactive_count if proactive_count > 0 else 0.0 - if score >= 16 and reply_rate >= 0.35: - relationship_stage = "亲近" - elif score >= 3 or inbound_count >= 1 or reply_rate >= 0.2: - relationship_stage = "熟悉" - else: - relationship_stage = "陌生" role = self.plugin._private_user_role(user, user_id_text) if hasattr(self.plugin, "_private_user_role") else "" role_labeler = getattr(self.plugin, "_private_user_role_label", None) role_label = role_labeler(role) if callable(role_labeler) else ("主要用户" if role == "owner" else "次要用户") @@ -9868,6 +9893,36 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio pending_emotion_judgement = self._emotion_pending_judgement_summary(user.get("pending_emotion_judgement")) last_emotion_judgement_error = self._single_line(user.get("last_emotion_judgement_error"), 160) relationship_intimacy = self._relationship_intimacy_projection(self._int(user.get("relationship_score"))) + relationship_mode = normalize_relationship_mode(user.get("relationship_mode"), role) + ledger_summary = relationship_ledger_summary(user) + relationship_intimacy["trend"] = ledger_summary.get("trend", "steady") + relationship_intimacy["recent_delta"] = ledger_summary.get("recent_delta", 0) + current_interaction = current_interaction_projection( + user.get("current_interaction"), + relationship_role=role, + relationship_mode=relationship_mode, + now=time.time(), + ) + if relationship_mode == "owner_exclusive": + relationship_intimacy["owner_exclusive"] = { + "label": self._single_line(getattr(self.plugin, "owner_exclusive_label", "专属联结"), 20) or "专属联结", + "tone": self._single_line(getattr(self.plugin, "owner_exclusive_tone", "温暖、亲近、稳定"), 120), + "address_level": self._single_line( + getattr(self.plugin, "owner_exclusive_address_style", "优先使用已确认的专属称呼"), + 100, + ), + "proactive_care_limit": max(0, self._int(getattr(self.plugin, "owner_exclusive_proactive_limit", 6))), + "fixed": True, + } + relationship_stage = self._single_line( + getattr(self.plugin, "owner_exclusive_label", "专属联结"), + 20, + ) or "专属联结" + else: + relationship_stage = self._single_line( + (relationship_intimacy.get("phase") or {}).get("label"), + 20, + ) or relationship_stage return { "user_id": user_id_text, "display_name": display_name, @@ -9939,12 +9994,25 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "reply_count": user.get("reply_count", 0), "proactive_sent_count": user.get("proactive_sent_count", 0), "relationship_score": user.get("relationship_score", 0), + "relationship_mode": relationship_mode, + "relationship_mode_label": ( + self._single_line(getattr(self.plugin, "owner_exclusive_label", "专属联结"), 20) or "专属联结" + if relationship_mode == "owner_exclusive" + else "普通关系" + ), "relationship_basis": { "value": relationship_intimacy["value"], "band": relationship_intimacy["phase"]["label"], }, "relationship_intimacy": relationship_intimacy, "relationship_stage": relationship_stage, + "relationship_ledger": ledger_summary, + "current_interaction": current_interaction, + "expression_authority": { + "current_interaction": "authoritative", + "expression_decision": "authoritative", + "relationship_state": "legacy_compat_read_only", + }, "relationship_state": relationship_state, "pending_emotion_judgement": pending_emotion_judgement, "last_emotion_judgement_error": last_emotion_judgement_error, @@ -9990,7 +10058,11 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "last_intent_confidence", "last_emotion_confidence", } - summary: dict[str, Any] = {} + summary: dict[str, Any] = { + "compatibility": "legacy_read_only", + "authoritative": False, + "current_authority": "current_interaction", + } for key, limit in scalar_limits.items(): if key in state: summary[key] = self._single_line(state.get(key), limit) @@ -10095,12 +10167,13 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio return None def _worldbook_member_profile_summary(self, user_id: str, item: dict[str, Any]) -> dict[str, Any]: + observation_only = bool(item.get("observation_only", False)) aliases = item.get("aliases") if isinstance(item.get("aliases"), list) else [] observed = item.get("observed_names") if isinstance(item.get("observed_names"), list) else [] external_ids = item.get("external_ids") if isinstance(item.get("external_ids"), list) else [] - memories = self._normalize_important_memories(item.get("important_memories")) - pending = item.get("pending_observations") if isinstance(item.get("pending_observations"), list) else [] - return { + memories = [] if observation_only else self._normalize_important_memories(item.get("important_memories")) + pending = [] if observation_only else (item.get("pending_observations") if isinstance(item.get("pending_observations"), list) else []) + summary = { "user_id": self._single_line(user_id, 40), "identity_type": self._single_line(item.get("identity_type") or ("qq" if str(user_id).isdigit() else "external"), 20), "name": self._single_line(item.get("name"), 60), @@ -10112,6 +10185,19 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "external_ids": [self._single_line(ext, 80) for ext in external_ids if self._single_line(ext, 80)], "linked_qq_user_id": self._single_line(item.get("linked_qq_user_id") or item.get("merged_into_user_id"), 40), "linked_bili_profile_id": self._single_line(item.get("linked_bili_profile_id"), 80), + "profile_origin": self._single_line(item.get("profile_origin"), 40), + "observation_only": observation_only, + "proactive_contact_enabled": bool(item.get("proactive_contact_enabled", False)), + "private_memory_enabled": bool(item.get("private_memory_enabled", False)), + "cross_group_memory_enabled": bool(item.get("cross_group_memory_enabled", False)), + "p4_eligible": bool(item.get("p4_eligible", False)), + "observed_group_count": len( + { + self._single_line(group_id, 80) + for group_id in (item.get("group_observation_scope_ids") if isinstance(item.get("group_observation_scope_ids"), list) else []) + if self._single_line(group_id, 80) + } + ), "content": self._single_line(item.get("content"), 260), "identity_note": self._single_line(item.get("identity_note") or item.get("note") or item.get("content"), 500), "boundary_note": self._single_line(item.get("boundary_note"), 500), @@ -10120,6 +10206,16 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "source_entries": item.get("source_entries") if isinstance(item.get("source_entries"), list) else [], "note": self._single_line(item.get("note"), 500), } + if observation_only: + summary.update( + { + "proactive_contact_enabled": False, + "private_memory_enabled": False, + "cross_group_memory_enabled": False, + "p4_eligible": False, + } + ) + return summary def _behavior_habit_summary(self, user: dict[str, Any]) -> dict[str, Any]: formatter = getattr(self.plugin, "_qualified_user_behavior_habits", None) @@ -13042,9 +13138,22 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "default_nickname_strategy", "default_relationship_role", "default_relationship_score", + "default_interaction_band", "default_proactive_enabled", "default_proactive_daily_limit", "relationship_stage_policy", + "owner_exclusive_label", + "owner_exclusive_tone", + "owner_exclusive_address_style", + "owner_exclusive_proactive_limit", + "relationship_event_window_minutes", + "relationship_positive_event_cap", + "relationship_negative_event_cap", + "relationship_positive_daily_cap", + "relationship_decay_grace_days", + "relationship_decay_early_per_day", + "relationship_decay_middle_per_day", + "relationship_decay_late_per_day", "reply_style_prompt", "enable_persona_voice_channels", "persona_conversation_voice_prompt", @@ -15605,9 +15714,22 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "default_nickname_strategy", "default_relationship_role", "default_relationship_score", + "default_interaction_band", "default_proactive_enabled", "default_proactive_daily_limit", "relationship_stage_policy", + "owner_exclusive_label", + "owner_exclusive_tone", + "owner_exclusive_address_style", + "owner_exclusive_proactive_limit", + "relationship_event_window_minutes", + "relationship_positive_event_cap", + "relationship_negative_event_cap", + "relationship_positive_daily_cap", + "relationship_decay_grace_days", + "relationship_decay_early_per_day", + "relationship_decay_middle_per_day", + "relationship_decay_late_per_day", "reply_style_prompt", "enable_persona_voice_channels", "persona_conversation_voice_prompt", @@ -16041,6 +16163,24 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio return "friend" if key == "default_relationship_score": return self._int(value, 0, -1200, 1200) + if key == "default_interaction_band": + text = self._single_line(value, 24).lower() + return text if text in {"avoidant", "hurt", "relaxed", "lively", "warm"} else "relaxed" + if key == "owner_exclusive_proactive_limit": + return self._int(value, 6, 0, 30) + relationship_integer_settings = { + "relationship_event_window_minutes": (30, 1, 1440), + "relationship_positive_event_cap": (4, 1, 30), + "relationship_negative_event_cap": (12, 1, 60), + "relationship_positive_daily_cap": (12, 0, 120), + "relationship_decay_grace_days": (3, 0, 30), + "relationship_decay_early_per_day": (2, 0, 30), + "relationship_decay_middle_per_day": (5, 0, 30), + "relationship_decay_late_per_day": (8, 0, 30), + } + if key in relationship_integer_settings: + default, minimum, maximum = relationship_integer_settings[key] + return self._int(value, default, minimum, maximum) if key == "default_proactive_daily_limit": return self._int(value, 0, 0, 30) expression_modes = { @@ -17435,15 +17575,38 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio pending_observation_total = self._int(data.get("worldbook_pending_observation_total")) if "worldbook_pending_observation_total" in data else 0 group_count = self._int(data.get("worldbook_group_profile_count")) if "worldbook_group_profile_count" in data else 0 entry_count = self._int(data.get("worldbook_entry_count")) if "worldbook_entry_count" in data else len(entries) + projection_stats = data.get("group_observation_profile_projection_stats") if isinstance(data.get("group_observation_profile_projection_stats"), dict) else {} + projection_counts_raw = projection_stats.get("counts") if isinstance(projection_stats.get("counts"), dict) else {} + projection_codes = ( + "created", + "updated", + "failed", + "skipped_empty_message", + "skipped_group_not_allowed", + "skipped_member_profiles_disabled", + "skipped_missing_sender", + "skipped_profile_handler_unavailable", + "skipped_invalid_identity", + "skipped_existing_authoritative_profile", + ) + projection_counts = { + code: self._clamp_int(projection_counts_raw.get(code), 0, 0, 999999) + for code in projection_codes + if self._clamp_int(projection_counts_raw.get(code), 0, 0, 999999) + } + last_projection_code = self._single_line(projection_stats.get("last_result_code"), 48) + if last_projection_code not in projection_codes: + last_projection_code = "" profile_items = [] for user_id, item in profiles.items(): if not isinstance(item, dict): continue + observation_only = bool(item.get("observation_only", False)) aliases = item.get("aliases") if isinstance(item.get("aliases"), list) else [] observed = item.get("observed_names") if isinstance(item.get("observed_names"), list) else [] external_ids = item.get("external_ids") if isinstance(item.get("external_ids"), list) else [] - memories = self._normalize_important_memories(item.get("important_memories")) - pending = item.get("pending_observations") if isinstance(item.get("pending_observations"), list) else [] + memories = [] if observation_only else self._normalize_important_memories(item.get("important_memories")) + pending = [] if observation_only else (item.get("pending_observations") if isinstance(item.get("pending_observations"), list) else []) pending_items = [] for raw in pending[:8]: if not isinstance(raw, dict): @@ -17475,7 +17638,7 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "linked_bili_profile_id": self._single_line(item.get("linked_bili_profile_id"), 80), "auto_registration_pending": bool(item.get("auto_registration_pending", False)), "profile_origin": self._single_line(item.get("profile_origin"), 40), - "observation_only": bool(item.get("observation_only", False)), + "observation_only": observation_only, "proactive_contact_enabled": bool(item.get("proactive_contact_enabled", False)), "relationship_state": self._single_line(item.get("relationship_state"), 24) or "neutral", "affinity_score": self._int(item.get("affinity_score")), @@ -17494,6 +17657,8 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "note": self._single_line(item.get("note"), 500), } ) + if observation_only: + profile_items[-1]["proactive_contact_enabled"] = False profile_items.sort(key=lambda item: (not item.get("enabled", True), item.get("name") or item.get("user_id"))) if "worldbook_member_profile_count" not in data: member_count = len(profile_items) @@ -17529,6 +17694,12 @@ class PrivateCompanionPageApi(PrivateCompanionPageApiQzoneMixin, PrivateCompanio "enabled_member_count": enabled_member_count, "pending_observation_total": pending_observation_total, "group_count": group_count, + "group_observation_projection": { + "last_result_code": last_projection_code, + "last_result_at": self.plugin._format_timestamp_elapsed(projection_stats.get("last_result_at", 0)), + "counts": projection_counts, + "total": sum(projection_counts.values()), + }, "last_import": self.plugin._format_timestamp_elapsed(state.get("last_import_at", 0)), "source_files": state.get("source_files") if isinstance(state.get("source_files"), list) else [], "members": profile_items[:120], diff --git a/page_api_users_groups.py b/page_api_users_groups.py index b65388f..0f61dff 100644 --- a/page_api_users_groups.py +++ b/page_api_users_groups.py @@ -10,7 +10,9 @@ from typing import Any from astrbot.api import logger from quart import request +from .companion_interaction_expression import allowed_expression_bands, current_interaction_projection from .helpers import _safe_int +from .relationship_ledger import normalize_relationship_mode, record_manual_relationship_change class PrivateCompanionPageApiUsersGroupsMixin: @@ -29,6 +31,119 @@ class PrivateCompanionPageApiUsersGroupsMixin: raise ValueError("relationship_score must be between -1200 and 1200") return score + def _observation_profile_by_user_id_locked( + self, + data: dict[str, Any], + user_id: str, + ) -> tuple[str, dict[str, Any]] | None: + """Resolve only an exact observation-only identity while the data lock is held.""" + identity = self._single_line(user_id, 40) + if not identity: + return None + finder = getattr(self.plugin, "_worldbook_group_observation_profile_by_identity", None) + if callable(finder): + candidate = finder(identity) + if ( + isinstance(candidate, tuple) + and len(candidate) == 2 + and isinstance(candidate[0], str) + and isinstance(candidate[1], dict) + and bool(candidate[1].get("observation_only")) + ): + return candidate[0], candidate[1] + profiles = data.get("worldbook_member_profiles") if isinstance(data.get("worldbook_member_profiles"), dict) else {} + profile = profiles.get(identity) + if isinstance(profile, dict) and bool(profile.get("observation_only")): + return identity, profile + return None + + def _observation_user_summary(self, profile_id: str, profile: dict[str, Any]) -> dict[str, Any]: + """Build a read-only user-page DTO without manufacturing a private user.""" + identity = self._single_line(profile.get("user_id") or profile_id, 40) + name = self._single_line(profile.get("name"), 60) or identity + last_seen = profile.get("last_observed_at", profile.get("auto_registered_ts", 0)) + scopes = profile.get("group_observation_scope_ids") if isinstance(profile.get("group_observation_scope_ids"), list) else [] + return { + "user_id": identity, + "display_name": name, + "nickname": name, + "style": "", + "is_qq_user": True, + "platform_kind": "onebot", + "platform_group": "qq", + "platform_label": "QQ", + "identity_label": "QQ 群聊观察", + "stable_platform_identity": True, + "source": "group_observation", + "profile_source": "group_observation", + "profile_source_label": "群聊观察", + "profile_kind": "observation", + "observation_only": True, + "group_observation_only": True, + "enabled": bool(profile.get("enabled", True)), + "relationship_role": "observer", + "relationship_mode": "observation_only", + "relationship_mode_label": "observation only", + "relationship_role_label": "仅观察对象", + "relationship_score": 0, + "relationship_ledger": {"items": [], "trend": "steady", "recent_delta": 0}, + "current_interaction": { + "expression_band": "relaxed", + "label": "relaxed", + "source": "group_observation", + "reason": "observation_only", + "updated_at": last_seen, + "expires_at": 0, + "manual_override": False, + "allowed_bands": [], + "reason_codes": ["observation_only"], + }, + "relationship_stage": "初识", + "relationship_state": {"mode": "neutral", "source": "group_observation"}, + "proactive_contact_enabled": False, + "private_memory_enabled": False, + "cross_group_memory_enabled": False, + "p4_eligible": False, + "effective_daily_limit": 0, + "effective_daily_limit_text": "不主动触达", + "last_seen_ts": last_seen, + "last_seen": self.plugin._format_timestamp_elapsed(last_seen), + "last_sent_ts": 0, + "last_sent": "", + "observed_group_count": len({self._single_line(item, 80) for item in scopes if self._single_line(item, 80)}), + "profile_origin": self._single_line(profile.get("profile_origin"), 40) or "group_observation", + } + + def _observation_user_detail(self, profile_id: str, profile: dict[str, Any]) -> dict[str, Any]: + detail = self._observation_user_summary(profile_id, profile) + member_summary = self._worldbook_member_profile_summary(profile_id, profile) + detail.update( + { + "relationship_panel": { + "observation_only": True, + "message": "群聊观察档案不进入私聊亲密度、主动联系或安全权限链路。", + }, + "memory": {}, + "expression_profile": {}, + "intent_profile": {}, + "behavior_habits": {"items": []}, + "dialogue_episodes": [], + "open_loops": [], + "recent_reply_topics": [], + "last_user_message": "", + "last_companion_message": "", + "delivery_route": {"available": False, "reason": "observation_only"}, + "worldbook_member": member_summary, + "p4_runtime": {"available": False, "reason": "observation_only"}, + "formatted": { + "relationship": "仅观察:中性,不进入私聊关系链路", + "action_affinity": "不主动触达", + "next_proactive": "不适用", + }, + } + ) + return detail + async def list_users(self) -> dict[str, Any]: start = time.perf_counter() try: @@ -38,12 +153,49 @@ class PrivateCompanionPageApiUsersGroupsMixin: if not isinstance(users, dict): users = {} user_items = [(user_id, dict(user)) for user_id, user in users.items() if isinstance(user, dict)] + profiles = self.plugin.data.get("worldbook_member_profiles", {}) + observation_items = [ + (str(profile_id), deepcopy(profile)) + for profile_id, profile in profiles.items() + if isinstance(profile, dict) and bool(profile.get("observation_only")) + ] if isinstance(profiles, dict) else [] items = [self._user_summary(user_id, user) for user_id, user in user_items] + for item in items: + item.setdefault("profile_kind", "private") + item.setdefault("profile_source", "private_chat") + item.setdefault("profile_source_label", "私聊用户") + item.setdefault("observation_only", False) + private_ids = {self._single_line(user_id, 40) for user_id, _ in user_items if self._single_line(user_id, 40)} + for profile_id, profile in observation_items: + identity = self._single_line(profile.get("user_id") or profile_id, 40) + # A real private user always wins the display slot. The + # observation profile remains a separate, non-authoritative + # source until an explicit future merge consumes it. + if not identity or identity in private_ids: + continue + items.append(self._observation_user_summary(profile_id, profile)) items.sort(key=lambda item: item.get("last_seen_ts") or 0, reverse=True) elapsed_ms = int((time.perf_counter() - start) * 1000) if elapsed_ms > 1200: logger.warning("[PrivateCompanionPage] 用户列表接口耗时较高: elapsed=%sms users=%s", elapsed_ms, len(items)) - return self._ok({"items": items[:limit], "total": len(items)}) + source_counts = { + "private_chat": sum(1 for item in items if item.get("profile_kind") == "private"), + "group_observation": sum(1 for item in items if item.get("observation_only")), + } + platform_counts: dict[str, int] = {} + for item in items: + platform = self._single_line(item.get("platform_group"), 32) or "web_other" + platform_counts[platform] = platform_counts.get(platform, 0) + 1 + return self._ok( + { + "items": items[:limit], + "total": len(items), + "private_total": source_counts["private_chat"], + "observation_total": source_counts["group_observation"], + "source_counts": source_counts, + "platform_counts": platform_counts, + } + ) except Exception as exc: logger.error(f"[PrivateCompanionPage] 获取用户列表失败: {exc}", exc_info=True) return self._error(str(exc)) @@ -54,7 +206,13 @@ class PrivateCompanionPageApiUsersGroupsMixin: try: async with self.plugin._data_lock: user = deepcopy((self.plugin.data.get("users") or {}).get(user_id)) + observation = None + if not isinstance(user, dict): + observation = self._observation_profile_by_user_id_locked(self.plugin.data, user_id) worldbook_member = self._worldbook_member_for_private_user_locked(self.plugin.data, user_id, user if isinstance(user, dict) else {}) + if observation is not None: + profile_id, profile = observation + return self._ok(self._observation_user_detail(profile_id, deepcopy(profile))) if not isinstance(user, dict): return self._error("用户不存在") detail = self._user_summary(user_id, user) @@ -64,6 +222,8 @@ class PrivateCompanionPageApiUsersGroupsMixin: relationship_stage=str(detail.get("relationship_stage") or ""), worldbook_member=worldbook_member, ) + detail["current_interaction"] = detail["relationship_panel"]["current_interaction"] + detail["expression_decision"] = detail["relationship_panel"]["expression_decision"] detail["p4_runtime"] = self._p4_page_status_projection() route_status_getter = getattr(self.plugin, "_private_delivery_route_status", None) delivery_route = route_status_getter(user_id, user) if callable(route_status_getter) else {} @@ -72,7 +232,7 @@ class PrivateCompanionPageApiUsersGroupsMixin: "memory": user.get("companion_memory") if isinstance(user.get("companion_memory"), dict) else {}, "expression_profile": self._expression_profile_summary(user), "intent_profile": user.get("intent_profile") if isinstance(user.get("intent_profile"), dict) else {}, - "relationship_state": user.get("relationship_state") if isinstance(user.get("relationship_state"), dict) else {}, + "relationship_state": detail.get("relationship_state") if isinstance(detail.get("relationship_state"), dict) else {}, "behavior_habits": self._behavior_habit_summary(user), "dialogue_episodes": self._limited_list(user.get("dialogue_episodes"), 12), "open_loops": self._limited_list(user.get("open_loops"), 12), @@ -106,11 +266,54 @@ class PrivateCompanionPageApiUsersGroupsMixin: relationship_score = self._relationship_score_input(payload.get(intimacy_keys[0])) except ValueError as exc: return self._error(str(exc)) + requested_mode = str(payload.get("relationship_mode") or "").strip().lower() if "relationship_mode" in payload else None + if requested_mode is not None and requested_mode not in {"normal", "owner_exclusive"}: + return self._error("relationship_mode must be normal or owner_exclusive") + requested_interaction_band = ( + str(payload.get("current_interaction_band") or "").strip().lower() + if "current_interaction_band" in payload + else None + ) + interaction_expires_at = 0.0 + if "current_interaction_expires_at" in payload: + raw_expiry = payload.get("current_interaction_expires_at") + if isinstance(raw_expiry, bool) or not isinstance(raw_expiry, (int, float)): + return self._error("current_interaction_expires_at must be a timestamp") + interaction_expires_at = float(raw_expiry) + if interaction_expires_at < 0 or interaction_expires_at > time.time() + 366 * 86400: + return self._error("current_interaction_expires_at is outside the allowed range") try: action_message = "" async with self.plugin._data_lock: + users = self.plugin.data.get("users") if isinstance(self.plugin.data.get("users"), dict) else {} + if not isinstance(users.get(user_id), dict) and self._observation_profile_by_user_id_locked(self.plugin.data, user_id): + return self._error("仅观察档案不能通过私聊用户接口修改") user = self.plugin._get_user(user_id) expression_voice_needs_refresh = False + previous_role = self.plugin._private_user_role(user, user_id) + previous_mode = normalize_relationship_mode(user.get("relationship_mode"), previous_role) + role = previous_role + if "relationship_role" in payload: + normalized_role = self.plugin._normalize_private_user_role(payload.get("relationship_role")) + if not normalized_role: + return self._error("relationship_role must be owner or friend") + role = normalized_role + next_mode = normalize_relationship_mode(requested_mode if requested_mode is not None else previous_mode, role) + if requested_mode == "owner_exclusive" and role != "owner": + return self._error("owner_exclusive relationship requires an owner user") + if previous_mode == "owner_exclusive" and role != "owner" and requested_mode != "normal": + return self._error("switch the relationship to a normal stage before changing the owner role") + if previous_mode == "owner_exclusive" and requested_mode == "normal" and relationship_score is None: + return self._error("leaving owner_exclusive requires selecting a normal relationship stage") + if previous_mode == "owner_exclusive" and relationship_score is not None and requested_mode != "normal": + return self._error("owner_exclusive relationship score is frozen; select a normal stage first") + if next_mode == "owner_exclusive" and relationship_score is not None: + return self._error("owner_exclusive relationship does not accept an exact score") + if requested_interaction_band is not None: + if not requested_interaction_band: + return self._error("current_interaction_band is required") + if requested_interaction_band not in allowed_expression_bands(role, next_mode): + return self._error("current interaction band is not allowed for this relationship") if "enabled" in payload: enabled = bool(payload.get("enabled")) user["enabled"] = enabled @@ -126,13 +329,45 @@ class PrivateCompanionPageApiUsersGroupsMixin: if "style" in payload: user["style"] = self._single_line(payload.get("style"), 24) if "relationship_role" in payload: - previous_role = self.plugin._private_user_role(user, user_id) - role = self.plugin._normalize_private_user_role(payload.get("relationship_role")) - if role: - user["relationship_role"] = role - expression_voice_needs_refresh = role != previous_role + user["relationship_role"] = role + expression_voice_needs_refresh = role != previous_role + if requested_mode is not None: + user["relationship_mode"] = next_mode + expression_voice_needs_refresh = expression_voice_needs_refresh or next_mode != previous_mode if relationship_score is not None: + previous_score = user.get("relationship_score", 0) user["relationship_score"] = relationship_score + record_manual_relationship_change( + user, + previous_score, + relationship_score, + now=time.time(), + reason_code="administrator_manual_relationship_adjustment", + ) + if requested_interaction_band is not None: + changed_at = time.time() + user["current_interaction"] = current_interaction_projection( + { + "expression_band": requested_interaction_band, + "source": "manual", + "operator": "page_administrator", + "reason": self._single_line(payload.get("current_interaction_reason"), 120) or "administrator_manual_override", + "updated_at": changed_at, + "expires_at": interaction_expires_at, + "manual_override": True, + }, + relationship_role=role, + relationship_mode=next_mode, + now=changed_at, + ) + expression_voice_needs_refresh = True + elif role != previous_role or next_mode != previous_mode: + user["current_interaction"] = current_interaction_projection( + user.get("current_interaction"), + relationship_role=role, + relationship_mode=next_mode, + now=time.time(), + ) if "proactive_daily_limit" in payload: user["proactive_daily_limit"] = _safe_int(payload.get("proactive_daily_limit"), -1, -1, 30) for key in ( @@ -171,7 +406,12 @@ class PrivateCompanionPageApiUsersGroupsMixin: self.plugin._clear_pending_proactive_plan(user) if payload.get("clear_emotion_state"): user["intent_profile"] = {} - user["relationship_state"] = {} + user.pop("relationship_state", None) + user["current_interaction"] = current_interaction_projection( + None, + relationship_role=user.get("relationship_role"), + relationship_mode=user.get("relationship_mode"), + ) if payload.get("clear_behavior_habits"): user["behavior_habits"] = {} if payload.get("clear_learning"): @@ -179,13 +419,13 @@ class PrivateCompanionPageApiUsersGroupsMixin: ("companion_memory", {}), ("expression_profile", {}), ("intent_profile", {}), - ("relationship_state", {}), ("recent_reply_topics", []), ("dialogue_episodes", []), ("open_loops", []), ("action_preferences", {}), ): user[key] = empty + user.pop("relationship_state", None) user["episode_message_count"] = 0 user["last_episode_refresh_at"] = 0 user["last_memory_refresh_at"] = 0 @@ -230,6 +470,8 @@ class PrivateCompanionPageApiUsersGroupsMixin: if not isinstance(users, dict): users = {} self.plugin.data["users"] = users + if not isinstance(users.get(user_id), dict) and self._observation_profile_by_user_id_locked(self.plugin.data, user_id): + return self._error("仅观察档案不能通过私聊用户接口删除") canonical_user_id = self.plugin._canonical_private_user_id(user_id) stored_user_id = canonical_user_id if canonical_user_id in users else user_id removed_ids = {user_id, canonical_user_id, stored_user_id} diff --git a/pages/陪伴面板/app.css b/pages/陪伴面板/app.css index f493f16..36afab9 100644 --- a/pages/陪伴面板/app.css +++ b/pages/陪伴面板/app.css @@ -2142,6 +2142,22 @@ input[type="search"] { font-size: 12px; } +.companion-intimacy-advanced { + border-top: 1px dashed color-mix(in srgb, var(--line) 82%, transparent); + padding-top: 9px; +} + +.companion-intimacy-advanced summary { + color: var(--muted); + cursor: pointer; + font-size: 12px; + font-weight: 700; +} + +.companion-intimacy-advanced .companion-intimacy-form { + margin-top: 10px; +} + .companion-intimacy-head p { margin: 5px 0 0; color: var(--muted); @@ -2166,7 +2182,7 @@ input[type="search"] { .relationship-stage-bar { display: grid; - grid-template-columns: repeat(8, minmax(72px, 1fr)); + grid-template-columns: repeat(9, minmax(72px, 1fr)); gap: 5px; overflow-x: auto; padding: 18px 1px 7px; @@ -2199,6 +2215,10 @@ input[type="search"] { box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 16%, transparent); } +.relationship-stage-segment.is-disabled { + opacity: 0.42; +} + .relationship-stage-segment b { position: absolute; top: -17px; @@ -2211,6 +2231,90 @@ input[type="search"] { font-size: 10px; } +.current-interaction-card { + display: grid; + gap: 10px; + border-top: 1px solid color-mix(in srgb, var(--accent) 20%, var(--line)); + padding-top: 13px; +} + +.current-interaction-head { + display: flex; + align-items: start; + justify-content: space-between; + gap: 12px; +} + +.current-interaction-head h3 { + margin: 2px 0 0; +} + +.current-interaction-head p { + margin: 5px 0 0; + color: var(--muted); + font-size: 12px; +} + +.current-interaction-head > strong { + color: var(--accent-strong); + font-size: 18px; + white-space: nowrap; +} + +.interaction-stage-bar { + display: grid; + grid-template-columns: repeat(7, minmax(0, 1fr)); + gap: 5px; + padding: 6px 1px; +} + +.interaction-stage-segment { + display: grid; + gap: 5px; + min-width: 0; + color: var(--muted); + font-size: 11px; + text-align: center; +} + +.interaction-stage-segment i { + display: block; + height: 7px; + border-radius: 999px; + background: color-mix(in srgb, var(--line) 84%, white 16%); +} + +.interaction-stage-segment.is-current { + color: var(--accent-strong); + font-weight: 700; +} + +.interaction-stage-segment.is-current i { + background: linear-gradient(90deg, var(--accent), var(--accent-strong)); + box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 16%, transparent); +} + +.interaction-stage-segment.is-disabled { + color: color-mix(in srgb, var(--muted) 56%, transparent); +} + +.interaction-stage-segment.is-disabled i { + background: color-mix(in srgb, var(--line) 55%, transparent); +} + +.current-interaction-meta { + display: flex; + flex-wrap: wrap; + gap: 5px 12px; + color: var(--text-muted); + font-size: 12px; +} + +.current-interaction-meta span { + min-width: 0; + overflow-wrap: anywhere; +} + .companion-intimacy-meta { flex-wrap: wrap; justify-content: flex-start; @@ -26940,3 +27044,60 @@ pre { animation: none !important; } } +.observation-profile-card { + display: grid; + gap: 18px; +} + +.observation-profile-card > header { + display: flex; + align-items: flex-start; + justify-content: space-between; + gap: 18px; + padding: 20px; + border: 1px solid var(--line); + border-radius: 18px; + background: linear-gradient(135deg, color-mix(in srgb, var(--panel) 92%, var(--accent) 8%), var(--panel)); +} + +.observation-profile-card > header h2, +.observation-profile-card > header p { + margin: 4px 0 0; +} + +.observation-boundary-grid { + display: grid; + grid-template-columns: repeat(4, minmax(0, 1fr)); + gap: 12px; +} + +.observation-boundary-grid section { + display: grid; + gap: 6px; + min-height: 112px; + padding: 16px; + border: 1px solid var(--line); + border-radius: 16px; + background: var(--panel); +} + +.observation-boundary-grid span, +.observation-boundary-grid small { + color: var(--muted); +} + +@media (max-width: 980px) { + .observation-boundary-grid { + grid-template-columns: repeat(2, minmax(0, 1fr)); + } +} + +@media (max-width: 620px) { + .observation-profile-card > header { + flex-direction: column; + } + + .observation-boundary-grid { + grid-template-columns: 1fr; + } +} diff --git a/pages/陪伴面板/app.js b/pages/陪伴面板/app.js index fcfb10b..aa6fccd 100644 --- a/pages/陪伴面板/app.js +++ b/pages/陪伴面板/app.js @@ -165,6 +165,7 @@ const hiddenCompatibilityConfigKeys = new Set([ "skill_growth_passive_injection", "skill_growth_custom_skills", "auto_voice_full_conversion_enabled", + "enable_relationship_analysis", ]); const featureSwitchNotes = { @@ -886,7 +887,7 @@ const providerGuides = { EMOTION_JUDGEMENT_PROVIDER_ID: { preference: "speed", passiveImpact: "async", - purpose: "可选复核用户消息是否会触发 Bot 自身短期情绪余波,只做分类判断,不生成回复。", + purpose: "可选复核用户消息是否应改变统一互动状态,只做分类判断,不生成回复。", fit: "适合便宜、低延迟、JSON 稳定、对玩笑/反讽/第三方抱怨判断保守的小模型。", fallback: "留空时先跟随排障检查模型,再回退到关系站位、陪伴通用和主模型。", }, @@ -1029,8 +1030,8 @@ const featureMeta = { enable_smart_silence: ["智能沉默", "私聊和群聊发送前判断是否应该收住话题;可只看明确边界,也可交给小模型结合上下文判断。"], enable_passive_topic_suppression: ["话题抑制", "避免短时间反复主动提同一个话题。"], enable_relationship_analysis: ["模型关系站位分析", "阶段性用完整人格和互动数据复核亲近程度与打扰偏好;可独立关闭模型调用。"], - enable_relationship_state_machine: ["关系距离感", "根据亲近、冷淡、边界和回应情况调整相处分寸。"], - enable_emotion_simulation: ["情绪模拟", "维护 Bot 自身被刺到、缓和、恢复和短暂回避的余波。"], + enable_relationship_state_machine: ["联系边界与互动状态", "把明确退开、重新靠近和未回应反馈收口到统一互动状态与主动边界。"], + enable_emotion_simulation: ["情绪事件参与互动状态", "让受伤、道歉、安抚、夸奖等事件只调整统一七档互动状态,不再维护第二套情绪分值。"], enable_dialogue_episode_memory: ["私聊片段", "把连续对话整理成共同经历和可续话头。"], enable_open_loop_tracking: ["未完话头", "记住对话里还留着、之后可能会回头接的事。"], enable_user_habit_learning: ["用户习惯画像", "学习用户常在什么时段做什么、问什么;被动只在相关时理解,主动可到点关心。"], @@ -1180,7 +1181,6 @@ const featureGroups = [ "enable_intent_emotion_analysis", "enable_proactive_message_review", "enable_passive_topic_suppression", - "enable_relationship_analysis", "enable_relationship_state_machine", "enable_dialogue_episode_memory", "enable_open_loop_tracking", @@ -1435,7 +1435,6 @@ const safeFeatureKeys = [ "enable_passive_response_review", "enable_framework_error_leak_guard", "enable_group_privacy_guard", - "enable_relationship_analysis", "enable_relationship_state_machine", "enable_dialogue_episode_memory", "enable_open_loop_tracking", @@ -1458,9 +1457,22 @@ const configLabels = { default_nickname: "默认称呼", default_relationship_role: "默认关系角色", default_relationship_score: "默认亲密度", + default_interaction_band: "默认互动状态", default_proactive_enabled: "允许新用户主动关心", default_proactive_daily_limit: "新用户每日主动上限", relationship_stage_policy: "八阶段策略", + owner_exclusive_label: "管理员专属关系名称", + owner_exclusive_tone: "管理员专属基础表达", + owner_exclusive_address_style: "管理员专属称呼尺度", + owner_exclusive_proactive_limit: "管理员专属主动阶段上限", + relationship_event_window_minutes: "同类事件合并窗口(分钟)", + relationship_positive_event_cap: "单次正向事件上限", + relationship_negative_event_cap: "单次负向事件上限", + relationship_positive_daily_cap: "每日正向增长上限", + relationship_decay_grace_days: "自然回落宽限期(天)", + relationship_decay_early_per_day: "早期每日回落值", + relationship_decay_middle_per_day: "中期每日回落值", + relationship_decay_late_per_day: "后期每日回落值", default_style: "默认语气", reply_style_prompt: "回复风格提示词", enable_persona_voice_channels: "启用分通道人格风格", @@ -1503,12 +1515,13 @@ const configLabels = { tts_conversion_provider_id: "TTS文本转换模型", tts_extra_prompt: "TTS补充规则", EMOTION_JUDGEMENT_PROVIDER_ID: "情绪变化判断模型", - enable_llm_emotion_judgement: "模型复核情绪变化", - emotion_judgement_mode: "情绪复核范围", - emotional_gate_hurt_threshold: "伤心触发阈值", - emotional_gate_refuse_threshold: "生气触发阈值", - emotional_gate_recovery_per_hour: "每小时缓和量", - emotional_gate_max_hurt_minutes: "最长收敛分钟", + enable_emotion_simulation: "让情绪事件自动调整互动状态", + enable_llm_emotion_judgement: "模型复核互动状态事件", + emotion_judgement_mode: "事件复核范围", + emotional_gate_hurt_threshold: "进入受伤档位阈值", + emotional_gate_refuse_threshold: "进入回避档位阈值", + emotional_gate_recovery_per_hour: "每小时恢复量", + emotional_gate_max_hurt_minutes: "受伤/回避最长分钟", enable_qzone_emotional_vent_publish: "公开心情动态", qzone_emotional_vent_threshold: "心情动态触发阈值", qzone_emotional_vent_cooldown_hours: "心情动态冷却小时", @@ -2007,9 +2020,22 @@ const configDescriptions = { default_style: "新用户基础语气。单用户设置和当前亲密度阶段策略优先于此默认值。", default_relationship_role: "自动档案固定为普通用户 / 朋友,不允许由默认配置成为主要用户。", default_relationship_score: "只影响之后自动创建的档案,不重写既有用户,范围 -1200 到 1200。", + default_interaction_band: "普通新用户可选择回避、受伤、放松、活泼或温暖;亲近和爱意不会自动授予。", default_proactive_enabled: "默认关闭。只有自动启用陪伴时才可能允许主动关心。", default_proactive_daily_limit: "新用户每天最多主动关心次数;未自动启用陪伴时强制为 0。", relationship_stage_policy: "固定八阶段键与阈值,只编辑显示、语气、称呼尺度和软行为,不能授予权限或绕过 P4。", + owner_exclusive_label: "只修改 owner 专属关系的显示名称,不增加管理或安全权限。", + owner_exclusive_tone: "专属关系的长期表达基线;当前互动状态仍可使本轮收敛。", + owner_exclusive_address_style: "优先沿用双方已确认的专属称呼。", + owner_exclusive_proactive_limit: "阶段硬上限,实际次数仍取全局、用户、阶段和动态额度的最小值。", + relationship_event_window_minutes: "同一用户的同类互动在该时间内只按一个关系事件结算,避免连续短消息重复刷分。", + relationship_positive_event_cap: "单个正向事件最多增加的长期亲密度;最终仍受每日正向增长上限约束。", + relationship_negative_event_cap: "单个负向事件最多降低的长期亲密度;负向事件不受正向每日上限抵消。", + relationship_positive_daily_cap: "每个用户每天由自动互动累计增加的长期亲密度上限;管理员手动调整不占用该额度。", + relationship_decay_grace_days: "用户停止互动后先保留的天数;宽限期结束才开始自然回落,owner 专属关系不会回落。", + relationship_decay_early_per_day: "超过宽限期后的第一段每日回落值,用于温和提醒关系需要持续互动。", + relationship_decay_middle_per_day: "长期未互动进入中段后每日回落值;只让正分向 0 靠近,不制造负分。", + relationship_decay_late_per_day: "更长时间未互动后的每日回落值;只让正分向 0 靠近,不突破安全和关系边界。", enable_proactive_only_mode: "开启后,本插件只保留主动私聊的日程、主动生成和发送链路;普通私聊、群聊消息不会再被本插件做状态/TTS/图片/转发/群聊上下文注入,也不会触发本插件的被动回复增强,但不会阻止 AstrBot 默认回复或其他插件处理。用户回复主动消息时仍会被轻量记为已回应。适合只想使用主动陪伴、或担心本插件被动链路误接管/误识别的场景。", enable_llm_proactive_message: "开启后,主动调度只负责挑选动机和时机,真正文本会调用 AstrBot 人格生成;关闭时回退为本地模板,更省但更机械。", enable_proactive_chat_integration: "检测到 Proactive Chat 时自动建立深度运行时联动:生成前检查两套调度是否撞车,并注入当前关系、状态、时机和已审核表达;生成后统一复核;平台发送无异常返回后才结算成功。不会修改对方插件文件或配置,也不会新建第二套定时任务。版本不兼容时自动降级为发送前装饰联动。", @@ -2488,13 +2514,14 @@ const configDescriptions = { proactive_review_low_score_threshold: "标准/严格强度下,候选价值分低于该值且压力较高时会延后。值越低越少延后,按百分比填写。", proactive_review_pressure_threshold: "标准/严格强度下,打扰压力达到该值且候选分偏低时会延后。值越高越少延后,按百分比填写。", response_review_max_chars: "用于判断普通被动回复是否偏长。默认模式会处理短闲聊被扩写成建议清单、天气小作文的情况;full 模式会更积极复核普通偏长回复。", - emotional_gate_hurt_threshold: "用户消息明确刺到 Bot、并达到该阈值后才会短期变安静;轻度玩笑和普通边界不会直接触发。", - emotional_gate_refuse_threshold: "累计刺痛感达到该阈值后才会明显不满或短暂回避;建议保持较高。", - emotional_gate_recovery_per_hour: "情绪余波每小时自然缓和多少分;数值越高越不容易长时间低落。", - emotional_gate_max_hurt_minutes: "单次刺痛事件最长收敛/暂停主动的分钟数;道歉或安抚可以提前恢复。", - enable_llm_emotion_judgement: "可选使用模型异步复核用户消息是否会改变 Bot 自身短期情绪余波;本轮被动回复仍使用缓存状态。", - emotion_judgement_mode: "模型复核范围:可疑项更省消耗,总是复核更细但更耗;结果主要影响后续轮次。", - EMOTION_JUDGEMENT_PROVIDER_ID: "用于异步复核用户消息是否会改变 Bot 自身短期情绪余波。建议选择便宜、低延迟、JSON 稳定、分类保守的小模型;留空会先回退到排障检查模型,再回退到关系站位/陪伴通用/主模型。", + enable_emotion_simulation: "开启后,受伤、道歉、安抚、夸奖、玩笑和亲近事件会直接结算到统一七档互动状态;不会再写第二套情绪分值或复合情绪状态。", + emotional_gate_hurt_threshold: "用户消息明确刺到 Bot、并达到该阈值后才进入统一的“受伤”互动档位;轻度玩笑和普通边界不会直接触发。", + emotional_gate_refuse_threshold: "单次明确伤害强度达到该阈值后进入统一的“回避”互动档位;它不是联系边界,也不会自动写入不再联系。", + emotional_gate_recovery_per_hour: "用于计算受伤/回避状态的预计持续时间;数值越高,越快回到长期关系基线。", + emotional_gate_max_hurt_minutes: "单次伤害事件的互动状态最长持续时间;道歉、安抚或明确重新靠近可以提前恢复。", + enable_llm_emotion_judgement: "可选使用模型异步复核用户消息属于哪一种互动事件;结果只进入统一互动状态,不生成另一套关系或情绪权威。", + emotion_judgement_mode: "模型复核范围:可疑项更省消耗,总是复核更细但更耗;结果主要影响后续互动状态。", + EMOTION_JUDGEMENT_PROVIDER_ID: "用于异步复核用户消息是否应改变统一互动状态。建议选择便宜、低延迟、JSON 稳定、分类保守的小模型;留空会先回退到排障检查模型,再回退到陪伴通用/主模型。", enable_qzone_emotional_vent_publish: "短期余波很重时是否允许低频发布公开心情说说。", qzone_emotional_vent_threshold: "触发公开心情动态所需的短期余波强度。", qzone_emotional_vent_cooldown_hours: "两次公开心情动态之间的最小间隔。", @@ -2564,8 +2591,29 @@ const advancedCycleSettingKeys = [ ]; const featureSettingGroups = { - enable_auto_user_profile_creation: ["auto_enable_companion_for_new_users", "auto_profile_platforms", "default_nickname_strategy", "default_nickname", "default_style", "default_relationship_role", "default_relationship_score", "default_proactive_enabled", "default_proactive_daily_limit"], - enable_custom_relationship_stage_policy: ["relationship_stage_policy"], + enable_auto_user_profile_creation: ["auto_enable_companion_for_new_users", "auto_profile_platforms", "default_nickname_strategy", "default_nickname", "default_style", "default_relationship_role", "default_relationship_score", "default_interaction_band", "default_proactive_enabled", "default_proactive_daily_limit"], + enable_custom_relationship_stage_policy: [ + "relationship_stage_policy", + "owner_exclusive_label", + "owner_exclusive_tone", + "owner_exclusive_address_style", + "owner_exclusive_proactive_limit", + "relationship_event_window_minutes", + "relationship_positive_event_cap", + "relationship_negative_event_cap", + "relationship_positive_daily_cap", + "relationship_decay_grace_days", + "relationship_decay_early_per_day", + "relationship_decay_middle_per_day", + "relationship_decay_late_per_day", + "enable_emotion_simulation", + "enable_llm_emotion_judgement", + "emotion_judgement_mode", + "EMOTION_JUDGEMENT_PROVIDER_ID", + "emotional_gate_hurt_threshold", + "emotional_gate_refuse_threshold", + "emotional_gate_max_hurt_minutes", + ], enable_mai_style_integration: [ "default_style", "reply_style_prompt", @@ -3161,8 +3209,8 @@ const featureSettingSections = { ], enable_emotion_simulation: [ { - title: "情绪余波", - note: "控制被刺到后的收敛、缓和、主动暂停和回复调节策略。", + title: "互动状态事件", + note: "控制明确伤害进入受伤/回避档位的阈值、恢复速度和主动暂停;不会生成第二套情绪分值。", keys: ["enable_llm_emotion_judgement", "emotion_judgement_mode", "EMOTION_JUDGEMENT_PROVIDER_ID", "emotional_gate_hurt_threshold", "emotional_gate_refuse_threshold", "emotional_gate_recovery_per_hour", "emotional_gate_max_hurt_minutes"], }, { @@ -3350,6 +3398,8 @@ const featureSettingTypes = { default_nickname_strategy: { type: "select", options: [["platform_display_name", "优先平台显示名"], ["fixed", "固定称呼"], ["user_id", "用户 ID"]] }, default_relationship_role: { type: "select", options: [["friend", "普通用户 / 朋友"]] }, default_relationship_score: { type: "number", min: -1200, max: 1200, step: 1 }, + default_interaction_band: { type: "select", options: [["avoidant", "回避"], ["hurt", "受伤"], ["relaxed", "放松"], ["lively", "活泼"], ["warm", "温暖"]] }, + owner_exclusive_proactive_limit: { type: "number", min: 0, max: 30, step: 1 }, default_proactive_enabled: { type: "checkbox" }, default_proactive_daily_limit: { type: "number", min: 0, max: 30, step: 1 }, forward_message_mode: { type: "select", options: [["inject", "注入"], ["transcribe", "转述"]] }, @@ -5427,7 +5477,7 @@ const setupGuideAdvancedBlocks = [ { id: "experimental", title: "实验性功能", - body: "配置情绪余波、需求强化、动机调度和角色贴合校准;人格标准化作为一次性工具入口单独使用。适合先小范围观察,确认拟人化收益大于打扰和成本后再稳定开启。", + body: "配置需求强化、动机调度和角色贴合校准;人格标准化作为一次性工具入口单独使用。互动状态事件已经并入亲密度阶段策略详情。", }, ]; @@ -5491,7 +5541,7 @@ const setupGuideAdvancedItems = { title: "模型关系站位分析", ask: "是否让模型阶段性复核与用户的亲近程度和打扰偏好?", description: "使用完整人格、互动次数、主动回复率和最近消息,生成陌生/熟悉/亲近及低打扰/普通/可轻分享判断。关闭后不会再产生“关系分析”模型 Token。", - caution: "关闭不会停用关系距离感:本地边界识别、未回复降频和互动数据兜底仍然保留,只是不再由模型定期重评。", + caution: "该旧模型关系站位功能已停用;长期关系阶段、统一互动状态、本地边界识别和未回复降频不依赖它。", kind: "feature", settings: [], }, @@ -5554,21 +5604,6 @@ const setupGuideAdvancedItems = { }, ], experimental: [ - { - key: "enable_emotion_simulation", - title: "情绪余波", - ask: "是否让 Bot 保留短期情绪余波,比如被刺到、缓和、恢复和短暂回避?", - description: "它能让回复不那么一键清空情绪,也能影响主动消息、空间说说和关系距离判断;迁入实验性功能后仍保留旧默认值。", - caution: "这是扮演状态,不是真实心理判断。阈值过低会让 Bot 太容易受伤,建议先温和开启并观察。", - kind: "feature", - settings: [ - { key: "enable_llm_emotion_judgement", type: "bool", label: "使用模型判断情绪变化", description: "比规则更细,但会增加轻量模型调用。" }, - { key: "emotion_judgement_mode", type: "select", label: "情绪判断模式", options: [["suspicious", "只判断可疑消息"], ["always", "每条普通文本都判断"], ["off", "关闭模型复核"]] }, - { key: "emotional_gate_hurt_threshold", type: "number", label: "受伤阈值", placeholder: "70", min: 10, max: 100, step: 5 }, - { key: "emotional_gate_refuse_threshold", type: "number", label: "生气阈值", placeholder: "90", min: 20, max: 100, step: 5 }, - { key: "emotional_gate_recovery_per_hour", type: "number", label: "每小时缓和量", placeholder: "24", min: 1, max: 60 }, - ], - }, { key: "enable_maslow_motivation_experiment", title: "需求强化功能", @@ -12369,11 +12404,11 @@ function renderUsers() { ${collapsed ? "" : users.map((user) => `