From e3f9e0b2124676e97cd7d47ee085b95dabc229c2 Mon Sep 17 00:00:00 2001 From: agent-bot Date: Mon, 27 Jul 2026 01:37:20 +0800 Subject: [PATCH] feat: complete M6.1.3-R2 through M6.1.7 bot personal archive contract MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit M6.1.3-R2 非五类兼容:值级隐私加固(base64/data URI/中缀路径/私钥), 真实陪伴 DTO 形状回归;信封字段剥离补全并统一先解包再剥离, 避免双插件分别部署时新旧载荷形状指纹不一致进死信。 M6.1.4 创作/媒体/主观分域:新增 idx_memories_domain_type_time; 路径中缀边界类扩为 ^|[\s=:;,]。 M6.1.5 Bot 专用检索 Profiles:新增 core/bot_profiles.py 定义五个 Profile, 固定域/类型/时间窗/条数/排序/注入字段/权限;新增 list_bot_profile_memories 把时间窗过滤下推到 SQL,避免近期记录过多时历史 Profile 静默返回空。 M6.1.6 分层只读 API:/bot-archive/{profiles,query,locked-frame},GET only。 M6.1.7 隐私权限收口:通用 memory_update/delete/lifecycle 拒绝 Bot 域写入 (此前可绕过受控归档路径,并使 payload_fingerprint 变陈导致后续归档进死信); 导出补 memory_domain 与域普查,修复 export→import 把 bot_self_schedule 降级成 bot_self_legacy 的问题。 测试:319 项通过(不含 test_security_cache,缺可选检索依赖)。 联合 E2E 135 项全部通过。 Co-Authored-By: Claude Opus 5 --- core/bot_personal.py | 219 ++++++++++++- core/bot_profiles.py | 155 ++++++++++ core/bridge.py | 80 +++-- core/models.py | 40 ++- core/operations.py | 11 + core/service.py | 278 ++++++++++++++--- core/store.py | 148 ++++++++- core/temporal_context.py | 12 + core/user_memory_boundary.py | 56 ++-- docs/运维记忆错题本.md | 133 ++++++++ docs/错题本.md | 40 +++ page_api.py | 92 +++++- tests/test_audit_batch1_fixes.py | 340 +++++++++++++++++++++ tests/test_bot_personal_memory.py | 338 +++++++++++++++----- tests/test_m6_r2_real_dto_shape.py | 357 ++++++++++++++++++++++ tests/test_m6_r4_creative_media_domain.py | 195 ++++++++++++ tests/test_m6_r5_bot_profiles.py | 280 +++++++++++++++++ tests/test_m6_r6_bot_archive_api.py | 198 ++++++++++++ tests/test_m6_r7_domain_isolation.py | 315 +++++++++++++++++++ 19 files changed, 3083 insertions(+), 204 deletions(-) create mode 100644 core/bot_profiles.py create mode 100644 tests/test_audit_batch1_fixes.py create mode 100644 tests/test_m6_r2_real_dto_shape.py create mode 100644 tests/test_m6_r4_creative_media_domain.py create mode 100644 tests/test_m6_r5_bot_profiles.py create mode 100644 tests/test_m6_r6_bot_archive_api.py create mode 100644 tests/test_m6_r7_domain_isolation.py diff --git a/core/bot_personal.py b/core/bot_personal.py index 03935b5..d0d14e4 100644 --- a/core/bot_personal.py +++ b/core/bot_personal.py @@ -1,13 +1,28 @@ from __future__ import annotations +import json +import re +from datetime import date as date_type +from datetime import datetime from typing import Any -from .models import clean_text, json_dumps +from .models import clean_text, stable_fingerprint BOT_PERSONAL_MEMORY_DOMAIN = "bot_self_schedule" BOT_PERSONAL_SESSION_ID = "bot_personal" BOT_PERSONAL_SCOPE = "private" BOT_PERSONAL_VISIBILITY = "bot_self" +BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION = "1.0" +BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION = "1.0" +BOT_PERSONAL_MAX_PAYLOAD_BYTES = 16 * 1024 +BOT_PERSONAL_WINDOWS = frozenset({"late_night", "morning", "afternoon", "evening"}) +# 信封字段:这些键只走 kwarg,留在 body 里会进指纹。created_at/updated_at 尤其危险—— +# 它们随墙钟漂移,会让同一条记录重投时变成 version_conflict。 +BOT_PERSONAL_ENVELOPE_KEYS = frozenset({ + "record_id", "memory_domain", "memory_type", "subject", "date", "window", "occurred_at", + "created_at", "updated_at", "source_kind", "source_refs", "certainty", "evidence_level", + "status", "version", "idempotency_key", "payload_schema_version", +}) BOT_PERSONAL_MEMORY_TYPES = { "bot_schedule_plan", @@ -24,24 +39,198 @@ BOT_PERSONAL_MEMORY_TYPES = { "bot_proactive_message", } +BOT_PERSONAL_TYPE_CONTRACTS = { + "bot_schedule_plan": {"source_kind": "planned", "evidence_level": "L0", "reality_level": "planned", "lifecycle": "planned_projection"}, + "bot_observed_activity": {"source_kind": "observed", "evidence_level": "caller", "reality_level": "observed_activity", "lifecycle": "stable_memory"}, + "bot_schedule_reconciliation": {"source_kind": "reconciled", "evidence_level": "caller", "reality_level": "reconciled", "lifecycle": "stable_memory"}, + "bot_window_snapshot": {"source_kind": "projection", "evidence_level": "caller", "reality_level": "window_projection", "lifecycle": "stable_memory"}, + "bot_daily_diary": {"source_kind": "subjective", "evidence_level": "caller", "reality_level": "subjective", "lifecycle": "stable_memory"}, + "bot_creative_work": {"source_kind": "creative", "evidence_level": "caller", "reality_level": "creative_work", "lifecycle": "stable_memory"}, + "bot_media_memory": {"source_kind": "media", "evidence_level": "caller", "reality_level": "media_index", "lifecycle": "stable_memory"}, + "bot_subjective_memory": {"source_kind": "subjective", "evidence_level": "caller", "reality_level": "subjective", "lifecycle": "stable_memory"}, + "bot_shared_activity": {"source_kind": "shared", "evidence_level": "caller", "reality_level": "shared_activity", "lifecycle": "stable_memory"}, + "bot_detail_fragment": {"source_kind": "detail", "evidence_level": "caller", "reality_level": "detail_fragment", "lifecycle": "stable_memory"}, + "bot_calendar_event": {"source_kind": "calendar", "evidence_level": "caller", "reality_level": "calendar_history", "lifecycle": "stable_memory"}, + "bot_proactive_message": {"source_kind": "proactive", "evidence_level": "caller", "reality_level": "proactive_action", "lifecycle": "stable_memory"}, +} + +_FORBIDDEN_KEY_PARTS = ( + "prompt", "chat", "conversation", "message_history", "raw_message", "cookie", "token", + "secret", "credential", "password", "authorization", "bearer", "base64", "binary", + "media_bytes", "image_bytes", "audio_bytes", "video_bytes", "file_path", "filepath", + "absolute_path", "local_path", "raw_payload", "transcript", +) +_FORBIDDEN_VALUE_PATTERNS = ( + re.compile(r"(?i)^bearer\s+\S+"), + re.compile(r"(?i)^(?:sk|ghp|xox[baprs])-[-_A-Za-z0-9]{12,}"), + re.compile(r"(?i)(?:password|passwd|secret|token|api[_-]?key)\s*[=:]\s*\S+"), + # 本机路径:前缀式(保留 R1 行为,比陪伴侧更严,任意 / 开头都拒) + re.compile(r"^(?:[A-Za-z]:[\\/]|/|\\\\)"), + # 本机路径:中缀式。R1 只锚定行首,"照片保存在 C:\\private\\a.png" 可绕过; + # 与陪伴侧 bot_personal_dto._looks_sensitive_value 对齐。clean_text 已把空白折叠成单空格, + # 因此 (?:^|[\s=]) 足以覆盖,不存在换行绕过。 + # 边界类含 : ; , 是因为路径常跟在分隔符后面(`photo:D:\...`、`标题:C:/x`),只有 ^|\s|= 会漏检。 + # `https://` 不受影响:`s:/` 前面是 `p`,不在边界类里。与陪伴侧 _looks_sensitive_value 保持一致。 + re.compile(r"(?i)(?:^|[\s=:;,])(?:[A-Za-z]:[\\/]|\\\\|/home/|/root/|/tmp/|/var/|/volume\d+/)"), + # 合同明确禁止 Base64 与媒体二进制 + re.compile(r"(?i)base64,"), + re.compile(r"(?i)^data:[a-z0-9.+-]*/?[a-z0-9.+-]*[;,]"), + # 私钥与证书材料 + re.compile(r"(?i)-----begin "), +) + + +class BotPersonalValidationError(ValueError): + def __init__(self, error_code: str, field: str = "", message: str = ""): + self.error_code = clean_text(error_code, 80) or "invalid_payload" + self.field = clean_text(field, 160) + self.message = clean_text(message, 300) or self.error_code + super().__init__(self.message) + + +def _field_name(value: Any) -> str: + return clean_text(value, 80).strip().lower().replace("-", "_") + + +def _sanitize_value(value: Any, *, path: str = "payload", depth: int = 0) -> Any: + if depth > 8: + raise BotPersonalValidationError("privacy_rejected", path, "payload nesting too deep") + if isinstance(value, dict): + if len(value) > 64: + raise BotPersonalValidationError("payload_too_large", path, "too many payload fields") + result: dict[str, Any] = {} + for raw_key, raw_value in value.items(): + key = clean_text(raw_key, 80) + normalized_key = _field_name(key) + if not key: + raise BotPersonalValidationError("invalid_field", path, "empty payload key") + if any(part in normalized_key for part in _FORBIDDEN_KEY_PARTS): + raise BotPersonalValidationError("privacy_rejected", f"{path}.{key}", "sensitive or raw field is not accepted") + result[key] = _sanitize_value(raw_value, path=f"{path}.{key}", depth=depth + 1) + return result + if isinstance(value, (list, tuple)): + if len(value) > 64: + raise BotPersonalValidationError("payload_too_large", path, "too many list items") + return [_sanitize_value(item, path=f"{path}[{index}]", depth=depth + 1) for index, item in enumerate(value)] + if isinstance(value, str): + text = clean_text(value, BOT_PERSONAL_MAX_PAYLOAD_BYTES) + if any(pattern.search(text) for pattern in _FORBIDDEN_VALUE_PATTERNS): + raise BotPersonalValidationError("privacy_rejected", path, "credential, base64 or local path is not accepted") + return text + if value is None or isinstance(value, (bool, int, float)): + return value + raise BotPersonalValidationError("invalid_field", path, "unsupported payload value") + + +def _raw_payload_size(value: Any) -> int: + try: + return len(json.dumps(value, ensure_ascii=False, separators=(",", ":")).encode("utf-8")) + except (TypeError, ValueError, OverflowError) as exc: + raise BotPersonalValidationError("invalid_payload", "payload", f"payload is not JSON serializable: {exc}") + def normalize_bot_personal_payload(value: Any, limit: int = 1200) -> dict[str, Any]: if not isinstance(value, dict): - return {} - result: dict[str, Any] = {} - for key, item in list(value.items())[:32]: - name = clean_text(key, 80) - if not name or name in {"user", "group", "event", "raw_message", "prompt"}: - continue - if isinstance(item, (str, int, float, bool)) or item is None: - result[name] = clean_text(item, limit) if isinstance(item, str) else item - elif isinstance(item, dict): - result[name] = normalize_bot_personal_payload(item, 320) - elif isinstance(item, (list, tuple)): - result[name] = [clean_text(entry, 240) if isinstance(entry, str) else entry for entry in list(item)[:24]] - return result + raise BotPersonalValidationError("invalid_payload", "payload", "payload must be an object") + if _raw_payload_size(value) > BOT_PERSONAL_MAX_PAYLOAD_BYTES: + raise BotPersonalValidationError("payload_too_large", "payload", "raw payload exceeds maximum size") + sanitized = _sanitize_value(value, path="payload") + if len(json.dumps(sanitized, ensure_ascii=False, separators=(",", ":")).encode("utf-8")) > BOT_PERSONAL_MAX_PAYLOAD_BYTES: + raise BotPersonalValidationError("payload_too_large", "payload", "payload exceeds maximum size") + return sanitized + + +def validate_bot_personal_envelope(*, memory_type: str, payload: dict[str, Any], date: str, occurred_at: str, source_refs: Any, window: str, certainty: Any, evidence_level: str, version: Any, idempotency_key: str, payload_schema_version: str, status: str = "") -> dict[str, Any]: + normalized_type = clean_text(memory_type, 80).lower() + if normalized_type not in BOT_PERSONAL_MEMORY_TYPES: + raise BotPersonalValidationError("invalid_memory_type", "memory_type", normalized_type or "missing") + if not isinstance(payload, dict): + raise BotPersonalValidationError("invalid_payload", "payload", "payload must be an object") + record_date = clean_text(date, 40) + try: + date_type.fromisoformat(record_date) + except ValueError: + raise BotPersonalValidationError("invalid_date", "date", record_date or "missing") + normalized_window = clean_text(window, 40).lower() + if normalized_window not in BOT_PERSONAL_WINDOWS: + raise BotPersonalValidationError("invalid_window", "window", normalized_window or "missing") + occurred = clean_text(occurred_at, 80) + try: + parsed_occurred = datetime.fromisoformat(occurred.replace("Z", "+00:00")) + except ValueError: + raise BotPersonalValidationError("invalid_occurred_at", "occurred_at", occurred or "missing") + if parsed_occurred.tzinfo is None or parsed_occurred.utcoffset() is None: + raise BotPersonalValidationError("invalid_occurred_at", "occurred_at", "timezone offset is required") + try: + refs_value = _sanitize_value({"source_refs": source_refs}, path="source_refs").get("source_refs") + except BotPersonalValidationError: + raise + refs = [clean_text(item, 240) for item in (refs_value if isinstance(refs_value, list) else []) if clean_text(item, 240)] + if not refs: + raise BotPersonalValidationError("missing_source_refs", "source_refs", "at least one source reference is required") + try: + certainty_value = float(certainty) + except (TypeError, ValueError): + raise BotPersonalValidationError("invalid_certainty", "certainty", "certainty must be numeric") + if not 0.0 <= certainty_value <= 1.0: + raise BotPersonalValidationError("invalid_certainty", "certainty", "certainty must be between 0 and 1") + normalized_evidence = clean_text(evidence_level, 40).upper() + if normalized_evidence not in {"L0", "L1", "L2", "L3"}: + raise BotPersonalValidationError("invalid_evidence_level", "evidence_level", normalized_evidence or "missing") + if normalized_type == "bot_schedule_plan" and normalized_evidence != "L0": + raise BotPersonalValidationError("invalid_evidence_level", "evidence_level", "bot_schedule_plan requires L0") + try: + version_value = int(version) + except (TypeError, ValueError): + raise BotPersonalValidationError("invalid_version", "version", "version must be a positive integer") + if version_value < 1: + raise BotPersonalValidationError("invalid_version", "version", "version must be a positive integer") + key = clean_text(idempotency_key, 240) + if not key: + raise BotPersonalValidationError("missing_idempotency_key", "idempotency_key", "idempotency_key is required") + schema = clean_text(payload_schema_version, 40) + if schema != BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION: + raise BotPersonalValidationError("unsupported_payload_schema", "payload_schema_version", schema or "missing") + return { + "memory_type": normalized_type, + "date": record_date, + "occurred_at": occurred, + "source_refs": refs, + "window": normalized_window, + "certainty": certainty_value, + "evidence_level": normalized_evidence, + "version": version_value, + "idempotency_key": key, + "payload_schema_version": schema, + "status": clean_text(status, 60), + } + + +def bot_personal_record_id(memory_type: str, idempotency_key: str) -> str: + return "botmem_" + stable_fingerprint(BOT_PERSONAL_MEMORY_DOMAIN, clean_text(memory_type, 80).lower(), clean_text(idempotency_key, 240))[:24] + + +def bot_personal_payload_fingerprint(*, memory_type: str, payload: dict[str, Any], date: str, window: str, occurred_at: str, source_refs: list[str], certainty: float, evidence_level: str, status: str, version: int, idempotency_key: str, payload_schema_version: str, source_kind: str) -> str: + canonical = { + "memory_type": clean_text(memory_type, 80).lower(), + "payload": payload, + "date": clean_text(date, 40), + "window": clean_text(window, 40), + "occurred_at": clean_text(occurred_at, 80), + "source_refs": list(source_refs), + "certainty": float(certainty), + "evidence_level": clean_text(evidence_level, 40).upper(), + "status": clean_text(status, 60), + "version": int(version), + "idempotency_key": clean_text(idempotency_key, 240), + "payload_schema_version": clean_text(payload_schema_version, 40), + "source_kind": clean_text(source_kind, 60), + } + canonical_json = json.dumps(canonical, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + return stable_fingerprint(canonical_json) def bot_personal_content(memory_type: str, payload: dict[str, Any]) -> str: label = clean_text(memory_type, 80) - return f"Bot个人记忆[{label}]:{json_dumps(normalize_bot_personal_payload(payload, 800))}" \ No newline at end of file + summary = clean_text(payload.get("summary") or payload.get("title") or payload.get("activity") or label, 800) + return f"Bot个人归档[{label}]:{summary}" diff --git a/core/bot_profiles.py b/core/bot_profiles.py new file mode 100644 index 0000000..0d40695 --- /dev/null +++ b/core/bot_profiles.py @@ -0,0 +1,155 @@ +"""M6.1.5 Bot 专用检索 Profile 定义。 + +每个 Profile 固定七件事:允许域、允许类型、时间范围、最大条数、排序、注入字段、权限。 +调用方只能选 Profile 名,不能自带过滤条件——否则「专用检索」会退化成把一堆类型塞进 +一次通用检索(M6.1.5 之前正是如此:陪伴侧一次性传 11 个 memory_type,拼一个 1400 字的 +大 query,当前状态和历史记忆混在同一批结果里,谁也分不清「现在要做什么」和「昨天做了什么」)。 + +时间范围用 `min_age_days` / `max_age_days` 表达,都以「相对现在的天数」计: +- `bot_schedule_current` 只看最近 1 天,回答「现在/今天」; +- `bot_schedule_history` 从 1 天前起算,回答「昨天/过去」——两者刻意不重叠, + 这样历史结果永远不可能被当成当前运行态。 +""" +from __future__ import annotations + +from datetime import datetime, timedelta +from typing import Any + +BOT_PROFILE_DOMAIN = "bot_self_schedule" + +# 注入字段白名单。serialize_memory 会带出全部 metadata(人格权重、指纹、幂等键等内部字段), +# 原样注进提示词既浪费预算又外泄内部结构,所以每个 Profile 只投影自己需要的字段。 +_BASE_FIELDS = ("id", "memory_type", "content", "occurred_at", "date", "window", "reality_level") + +BOT_RETRIEVAL_PROFILES: dict[str, dict[str, Any]] = { + "bot_schedule_current": { + "description": "当前窗口的运行态补充:只用于补足本地日程,不能替代它", + "memory_types": ("bot_schedule_plan", "bot_observed_activity", + "bot_window_snapshot", "bot_schedule_reconciliation"), + "min_age_days": None, + "max_age_days": 1, + "limit": 6, + "order": "occurred_at_desc", + "fields": _BASE_FIELDS + ("source_kind", "status"), + }, + "bot_schedule_history": { + "description": "回忆过去的日程:起点是 1 天前,与 current 刻意不重叠", + "memory_types": ("bot_schedule_plan", "bot_observed_activity", "bot_schedule_reconciliation", + "bot_window_snapshot", "bot_calendar_event", "bot_detail_fragment"), + "min_age_days": 1, + "max_age_days": 90, + "limit": 8, + "order": "occurred_at_desc", + "fields": _BASE_FIELDS + ("source_kind", "status"), + }, + "bot_creative": { + "description": "创作里程碑与媒体索引", + "memory_types": ("bot_creative_work", "bot_media_memory"), + "min_age_days": None, + "max_age_days": 180, + "limit": 6, + "order": "occurred_at_desc", + "fields": _BASE_FIELDS + ("source_kind",), + }, + "bot_subjective": { + "description": "主观内容:梦境与日记,必须可被识别为主观而非事实", + "memory_types": ("bot_subjective_memory", "bot_daily_diary"), + "min_age_days": None, + "max_age_days": 90, + "limit": 5, + "order": "occurred_at_desc", + "fields": _BASE_FIELDS + ("epistemic_type",), + }, + "locked_frame_personal": { + "description": "Locked Frame 人格连续性:近期全类型少量取样", + "memory_types": ("bot_schedule_plan", "bot_observed_activity", "bot_schedule_reconciliation", + "bot_window_snapshot", "bot_daily_diary", "bot_creative_work", + "bot_media_memory", "bot_subjective_memory", "bot_shared_activity", + "bot_detail_fragment", "bot_calendar_event", "bot_proactive_message"), + "min_age_days": None, + "max_age_days": 7, + "limit": 10, + "order": "occurred_at_desc", + "fields": _BASE_FIELDS + ("source_kind", "epistemic_type"), + }, +} + +BOT_PROFILE_NAMES = tuple(BOT_RETRIEVAL_PROFILES) + + +class BotProfileError(ValueError): + def __init__(self, error_code: str, message: str = "") -> None: + self.error_code = error_code + self.message = message or error_code + super().__init__(self.message) + + +def get_bot_profile(name: str) -> dict[str, Any]: + profile = BOT_RETRIEVAL_PROFILES.get(str(name or "").strip().lower()) + if not profile: + raise BotProfileError("unknown_profile", f"unknown bot retrieval profile: {name}") + return profile + + +def _parse_moment(value: Any) -> datetime | None: + try: + return datetime.fromisoformat(str(value or "").replace("Z", "+00:00")) + except (TypeError, ValueError): + return None + + +def profile_time_bounds(profile: dict[str, Any], now: datetime) -> tuple[datetime | None, datetime | None]: + """返回 (最早, 最晚)。最晚由 min_age_days 决定——它把「太新」的记录挡在历史 Profile 之外。""" + earliest = None + latest = None + if profile.get("max_age_days") is not None: + earliest = now - timedelta(days=int(profile["max_age_days"])) + if profile.get("min_age_days") is not None: + latest = now - timedelta(days=int(profile["min_age_days"])) + return earliest, latest + + +def record_within_profile_window(occurred_at: Any, profile: dict[str, Any], now: datetime) -> bool: + moment = _parse_moment(occurred_at) + if moment is None: + # 时间解析不了就不进任何 Profile:宁可少注入,也不要把无法定位时间的记录 + # 当成「当前」或「历史」注进提示词。 + return False + if moment.tzinfo is None: + return False + earliest, latest = profile_time_bounds(profile, now) + if earliest is not None and moment < earliest: + return False + if latest is not None and moment > latest: + return False + return True + + +def project_profile_fields(item: dict[str, Any], profile: dict[str, Any]) -> dict[str, Any]: + """按 Profile 的注入字段白名单投影,metadata 里的字段允许上浮到顶层。""" + metadata = item.get("metadata") if isinstance(item.get("metadata"), dict) else {} + projected: dict[str, Any] = {} + for field in profile["fields"]: + if field in item and item.get(field) not in (None, ""): + projected[field] = item[field] + elif field in metadata and metadata.get(field) not in (None, ""): + projected[field] = metadata[field] + return projected + + +def describe_bot_profiles() -> dict[str, Any]: + """capability 用:把 Profile 契约原样暴露给调用方,避免两侧各自猜测限制。""" + return { + name: { + "description": profile["description"], + "memory_domain": BOT_PROFILE_DOMAIN, + "memory_types": list(profile["memory_types"]), + "min_age_days": profile["min_age_days"], + "max_age_days": profile["max_age_days"], + "limit": profile["limit"], + "order": profile["order"], + "fields": list(profile["fields"]), + "read_only": True, + } + for name, profile in BOT_RETRIEVAL_PROFILES.items() + } diff --git a/core/bridge.py b/core/bridge.py index 5357289..e1a168c 100644 --- a/core/bridge.py +++ b/core/bridge.py @@ -305,65 +305,58 @@ class MemoryCompanionBridge: occurred_at: str = "", idempotency_key: str = "", **kwargs: Any, - ) -> str: + ) -> dict[str, Any]: recorder = getattr(self._plugin, "record_bot_personal_memory", None) if not callable(recorder): - raise RuntimeError("bot_personal_memory_unavailable") - return await recorder( + return {"ok": False, "record_id": "", "deduplicated": False, "version": 0, "error_code": "bridge_method_unavailable"} + result = await recorder( memory_type=memory_type, payload=payload or {}, occurred_at=occurred_at, idempotency_key=idempotency_key, **kwargs, ) + return result if isinstance(result, dict) else {"ok": False, "record_id": "", "deduplicated": False, "version": 0, "error_code": "invalid_bridge_response"} - async def _record_bot_personal_type( - self, - memory_type: str, - *, - payload: dict[str, Any] | None = None, - occurred_at: str = "", - idempotency_key: str = "", - **kwargs: Any, - ) -> str: - return await self.record_bot_personal_memory( - memory_type=memory_type, - payload=payload, - occurred_at=occurred_at, - idempotency_key=idempotency_key, - **kwargs, - ) + async def _record_bot_personal_type(self, memory_type: str, **kwargs: Any) -> dict[str, Any]: + return await self.record_bot_personal_memory(memory_type=memory_type, **kwargs) - async def record_bot_schedule_plan(self, **kwargs: Any) -> str: + async def record_bot_schedule_plan(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_schedule_plan", **kwargs) - async def record_bot_observed_activity(self, **kwargs: Any) -> str: + async def record_bot_observed_activity(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_observed_activity", **kwargs) - async def record_bot_schedule_reconciliation(self, **kwargs: Any) -> str: + async def record_bot_schedule_reconciliation(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_schedule_reconciliation", **kwargs) - async def record_bot_window_snapshot(self, **kwargs: Any) -> str: + async def record_bot_window_snapshot(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_window_snapshot", **kwargs) - async def record_bot_daily_diary(self, **kwargs: Any) -> str: + async def record_bot_daily_diary(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_daily_diary", **kwargs) - async def record_bot_creative_work(self, **kwargs: Any) -> str: + async def record_bot_creative_work(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_creative_work", **kwargs) - async def record_bot_media_memory(self, **kwargs: Any) -> str: + async def record_bot_media_memory(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_media_memory", **kwargs) - async def record_bot_subjective_memory(self, **kwargs: Any) -> str: + async def record_bot_subjective_memory(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_subjective_memory", **kwargs) - async def record_bot_shared_activity(self, **kwargs: Any) -> str: + async def record_bot_shared_activity(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_shared_activity", **kwargs) - async def record_bot_detail_fragment(self, **kwargs: Any) -> str: + async def record_bot_detail_fragment(self, **kwargs: Any) -> dict[str, Any]: return await self._record_bot_personal_type("bot_detail_fragment", **kwargs) + async def record_bot_calendar_event(self, **kwargs: Any) -> dict[str, Any]: + return await self._record_bot_personal_type("bot_calendar_event", **kwargs) + + async def record_bot_proactive_message(self, **kwargs: Any) -> dict[str, Any]: + return await self._record_bot_personal_type("bot_proactive_message", **kwargs) + async def search_bot_personal_memory( self, query: str = "", @@ -375,6 +368,35 @@ class MemoryCompanionBridge: if not callable(getter): return [] return await getter(query, limit=limit, memory_types=memory_types) + + # ---- M6.1.5 Bot 专用检索 Profile ---- + # 调用方只选 Profile 名;域/类型/时间窗/条数/排序/注入字段全部由记忆侧固定, + # 不接受调用方自带过滤条件——那样就退回成全库通用检索了。 + + async def search_bot_personal_profile( + self, profile: str, query: str = "", *, limit: int | None = None, + ) -> dict[str, Any]: + getter = getattr(self._plugin, "search_bot_personal_profile", None) + if not callable(getter): + return {"profile": profile, "memories": [], "read_only": True, + "warnings": ["bridge_method_unavailable"]} + return await getter(profile, query, limit=limit) + + async def search_bot_schedule( + self, query: str = "", *, history: bool = False, limit: int | None = None, + ) -> dict[str, Any]: + """`history=False` 回答「现在要做什么」,`True` 回答「昨天做了什么」,两个窗口不重叠。""" + return await self.search_bot_personal_profile( + "bot_schedule_history" if history else "bot_schedule_current", query, limit=limit) + + async def search_bot_creative_memory(self, query: str = "", *, limit: int | None = None) -> dict[str, Any]: + return await self.search_bot_personal_profile("bot_creative", query, limit=limit) + + async def search_bot_subjective_memory(self, query: str = "", *, limit: int | None = None) -> dict[str, Any]: + return await self.search_bot_personal_profile("bot_subjective", query, limit=limit) + + async def search_locked_frame_personal_memory(self, query: str = "", *, limit: int | None = None) -> dict[str, Any]: + return await self.search_bot_personal_profile("locked_frame_personal", query, limit=limit) async def search( self, query: str, diff --git a/core/models.py b/core/models.py index b1ea7d0..c1e5e63 100644 --- a/core/models.py +++ b/core/models.py @@ -51,6 +51,42 @@ def stable_fingerprint(*parts: Any) -> str: return hashlib.sha1(raw.encode("utf-8", errors="ignore")).hexdigest() +# 域判定的唯一来源:`MemoryRecord.ensure_defaults` 与 `user_memory_boundary.infer_memory_domain` +# 必须使用同一份集合,避免两处内联清单漂移。这些常量定义在最底层模块, +# 由 `user_memory_boundary` 再导出,避免 models ←→ user_memory_boundary 循环导入。 +BOT_SELF_MEMORY_TYPES = frozenset({ + "self_action", + "persona_life", + "proactive_message", + "schedule_fragment", + "companion_note", + "calendar_event", + "agenda_snapshot", + "timeline_event", +}) +BOT_SELF_REALITY_LEVELS = frozenset({"bot_action", "persona_life", "llm_tool_assertion"}) +USER_MEMORY_TYPES = frozenset({ + "user_fact", + "user_event", + "user_decision", + "user_summary", + "user_profile", + "user_preference", + "user_habit", + "relationship_claim", + "explicit_memory", + "manual_memory", + "conversation_event", + "conversation_summary", + "important_event", + "daily_digest", + "tool_memory", +}) +# 用户记忆写入门禁独立于域判定:本地生成的衰减总结属于聚合产物, +# 不得经外部用户记忆 Bridge 当成用户事实写入,但它的域仍按来源片段判定。 +USER_MEMORY_WRITE_BLOCKED_TYPES = BOT_SELF_MEMORY_TYPES | {"memory_decay_summary"} + + @dataclass(slots=True) class EntityRef: kind: str = "user" @@ -145,9 +181,9 @@ class MemoryRecord: reality = clean_text(self.reality_level, 80).lower() if memory_type == "calendar_event": self.memory_domain = "calendar_history" - elif self.visibility == "bot_self" or reality in {"bot_action", "persona_life", "llm_tool_assertion"} or memory_type in {"self_action", "persona_life", "proactive_message", "schedule_fragment", "companion_note", "calendar_event", "agenda_snapshot", "timeline_event"}: + elif self.visibility == "bot_self" or reality in BOT_SELF_REALITY_LEVELS or memory_type in BOT_SELF_MEMORY_TYPES: self.memory_domain = "bot_self_legacy" - elif getattr(self.subject, "kind", "") == "user" or memory_type in {"user_fact", "user_event", "user_decision", "user_summary", "user_profile", "user_preference", "user_habit", "relationship_claim", "explicit_memory", "manual_memory", "conversation_event", "conversation_summary", "important_event", "daily_digest", "tool_memory"}: + elif getattr(self.subject, "kind", "") == "user" or memory_type in USER_MEMORY_TYPES: self.memory_domain = "user_memory" else: self.memory_domain = "unknown" diff --git a/core/operations.py b/core/operations.py index 9aa9a56..9a08692 100644 --- a/core/operations.py +++ b/core/operations.py @@ -313,6 +313,9 @@ class PortableMemoryArchive: timeline = await self.store.recent_timeline(limit=1_000_000) acl_rules = await self.store.list_acl_rules() acl_policies = await self.store.list_acl_policies() + domain_counts: dict[str, int] = {} + for memory in memories: + domain_counts[memory.memory_domain or "unknown"] = domain_counts.get(memory.memory_domain or "unknown", 0) + 1 counts = { "memory": len(memories), "identity": len(identities), @@ -332,6 +335,8 @@ class PortableMemoryArchive: "exported_at": now.isoformat(timespec="seconds"), "encoding": "utf-8", "counts": counts, + # 域普查:运维一眼能看出用户域/Bot 域各多少条,恢复后可据此核对没有串域 + "memory_domain_counts": domain_counts, "excluded": ["memory_embeddings", "injection_logs", "provider_credentials"], } fd, temp_name = tempfile.mkstemp(suffix=".tmp", prefix=path.stem, dir=str(path.parent)) @@ -501,6 +506,10 @@ class PortableMemoryArchive: return { "id": memory.id, "memory_type": memory.memory_type, + # 域必须随记录一起导出。缺了它,导入时 ensure_defaults 会按 visibility 重新推断, + # 把 bot_self_schedule 降级成 bot_self_legacy —— 检索 Profile 全部失效, + # 重新归档还会撞 domain_conflict。运维的备份恢复正好走这条路径。 + "memory_domain": memory.memory_domain, "subject": {"kind": memory.subject.kind, "id": memory.subject.id, "name": memory.subject.name, "role": memory.subject.role}, "object": {"kind": memory.object.kind, "id": memory.object.id, "name": memory.object.name, "role": memory.object.role}, "scope": memory.scope, @@ -537,6 +546,8 @@ class PortableMemoryArchive: return MemoryRecord( id=clean_text(data.get("id"), 120), memory_type=clean_text(data.get("memory_type"), 80) or "imported_memory", + # 老导出没有这个字段,留空则由 ensure_defaults 按 visibility 重新推断(旧行为) + memory_domain=clean_text(data.get("memory_domain"), 60), subject=EntityRef( kind=clean_text(subject.get("kind"), 40) or "user", id=clean_text(subject.get("id"), 120), diff --git a/core/service.py b/core/service.py index 4a0bc99..bb56397 100644 --- a/core/service.py +++ b/core/service.py @@ -30,15 +30,32 @@ from .astrbot_compat import ( ) from .bridge import serialize_memory from .bot_personal import ( + BOT_PERSONAL_ENVELOPE_KEYS, BOT_PERSONAL_MEMORY_DOMAIN, BOT_PERSONAL_MEMORY_TYPES, BOT_PERSONAL_SCOPE, BOT_PERSONAL_SESSION_ID, BOT_PERSONAL_VISIBILITY, + BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION, + BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION, + BOT_PERSONAL_MAX_PAYLOAD_BYTES, + BOT_PERSONAL_TYPE_CONTRACTS, + BotPersonalValidationError, bot_personal_content, + bot_personal_payload_fingerprint, + bot_personal_record_id, normalize_bot_personal_payload, + validate_bot_personal_envelope, ) -from .temporal_context import build_reply_delay +from .bot_profiles import ( + BotProfileError, + describe_bot_profiles, + get_bot_profile, + profile_time_bounds, + project_profile_fields, + record_within_profile_window, +) +from .temporal_context import build_reply_delay, local_now from .chat_import import HistoricalChatImporter from .classifier import MemoryClassifier from .config import ConfigView @@ -872,42 +889,125 @@ class MemoryCompanionService: occurred_at: str = "", idempotency_key: str = "", source_plugin: str = "private_companion", + source_refs: list[str] | None = None, + date: str = "", + window: str = "", + certainty: float | None = None, + evidence_level: str = "", + version: int | None = None, + payload_schema_version: str = "", + status: str = "", importance: float = 0.55, confidence: float = 0.82, - ) -> str: - normalized_type = clean_text(memory_type, 80).lower() - if normalized_type not in BOT_PERSONAL_MEMORY_TYPES: - raise UserMemoryBoundaryError(f"bot_personal_memory_type:{normalized_type or 'unknown'}") - safe_payload = normalize_bot_personal_payload(payload or {}) - key = clean_text(idempotency_key, 240) - memory_id = self.stable_id("bot_personal", key or normalized_type, json_dumps(safe_payload)) - metadata = dict(safe_payload) - metadata.update({ - "memory_domain": BOT_PERSONAL_MEMORY_DOMAIN, - "bot_personal": True, - "idempotency_key": key, - "source_refs": safe_payload.get("source_refs", []), - "epistemic_type": "subjective" if normalized_type == "bot_subjective_memory" else "observed", - }) - reality_level = "persona_life" if normalized_type in {"bot_subjective_memory", "bot_daily_diary"} else "bot_action" - return await self.record_external_event( - memory_id=memory_id, - content=bot_personal_content(normalized_type, safe_payload), - memory_type=normalized_type, - memory_domain=BOT_PERSONAL_MEMORY_DOMAIN, - scope=BOT_PERSONAL_SCOPE, - session_id=BOT_PERSONAL_SESSION_ID, - visibility=BOT_PERSONAL_VISIBILITY, - sayability="indirect", - reality_level=reality_level, - lifecycle="stable_memory", - confidence=confidence, - importance=importance, - tags=["bot_personal", normalized_type], - metadata=metadata, - source_plugin=source_plugin, - occurred_at=clean_text(occurred_at, 80), - ) + ) -> dict[str, Any]: + base = {"ok": False, "record_id": "", "deduplicated": False, "version": 0, "error_code": None} + if not self.config.bool("private_companion_bridge.accept_external_records", True): + return {**base, "error_code": "bridge_write_disabled"} + if payload is not None and not isinstance(payload, dict): + return {**base, "error_code": "invalid_payload", "error": "payload must be an object", "field": "payload"} + raw_payload = payload if isinstance(payload, dict) else {} + try: + safe_payload = normalize_bot_personal_payload(raw_payload) + # 兼容旧版陪伴:它把整包信封当 payload 送,除 payload 外全是信封字段。 + # 必须先解包再剥离——反过来的话内层的 source_refs 等字段会留在 body 里, + # 与新版直接送 body 的形状指纹不同,双插件分别部署的滚动升级窗口里 + # 同一条记录就会 version_conflict → 死信。 + body_source = safe_payload + inner_payload = safe_payload.get("payload") + if isinstance(inner_payload, dict) and set(safe_payload) - BOT_PERSONAL_ENVELOPE_KEYS == {"payload"}: + body_source = inner_payload + body_payload = { + key: value + for key, value in body_source.items() + if key not in BOT_PERSONAL_ENVELOPE_KEYS + } + envelope = validate_bot_personal_envelope( + memory_type=memory_type, + payload=body_payload, + date=date or safe_payload.get("date", ""), + occurred_at=occurred_at or safe_payload.get("occurred_at", ""), + source_refs=source_refs if source_refs is not None else safe_payload.get("source_refs"), + window=window or safe_payload.get("window", ""), + certainty=certainty if certainty is not None else safe_payload.get("certainty"), + evidence_level=evidence_level or safe_payload.get("evidence_level", ""), + version=version if version is not None else safe_payload.get("version"), + idempotency_key=idempotency_key or safe_payload.get("idempotency_key", ""), + payload_schema_version=payload_schema_version or safe_payload.get("payload_schema_version") or BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION, + status=status or safe_payload.get("status", ""), + ) + record_date = envelope["date"] + contract = BOT_PERSONAL_TYPE_CONTRACTS[envelope["memory_type"]] + record_id = bot_personal_record_id(envelope["memory_type"], envelope["idempotency_key"]) + status_value = envelope["status"] + evidence_value = contract["evidence_level"] if contract["evidence_level"] != "caller" else envelope["evidence_level"] + payload_fingerprint = bot_personal_payload_fingerprint( + memory_type=envelope["memory_type"], + payload=body_payload, + date=record_date, + window=envelope["window"], + occurred_at=envelope["occurred_at"], + source_refs=envelope["source_refs"], + certainty=envelope["certainty"], + evidence_level=evidence_value, + status=status_value, + version=envelope["version"], + idempotency_key=envelope["idempotency_key"], + payload_schema_version=envelope["payload_schema_version"], + source_kind=contract["source_kind"], + ) + metadata = dict(body_payload) + metadata.update({ + "memory_domain": BOT_PERSONAL_MEMORY_DOMAIN, + "bot_personal": True, + "date": record_date, + "window": envelope["window"], + "occurred_at": envelope["occurred_at"], + "source_kind": contract["source_kind"], + "source_refs": envelope["source_refs"], + "certainty": envelope["certainty"], + "evidence_level": contract["evidence_level"] if contract["evidence_level"] != "caller" else envelope["evidence_level"], + "version": envelope["version"], + "idempotency_key": envelope["idempotency_key"], + "payload_schema_version": envelope["payload_schema_version"], + "payload_fingerprint": payload_fingerprint, + "status": status_value, + "epistemic_type": "subjective" if envelope["memory_type"] == "bot_daily_diary" else contract["source_kind"], + }) + record = MemoryRecord( + id=record_id, + memory_type=envelope["memory_type"], + memory_domain=BOT_PERSONAL_MEMORY_DOMAIN, + subject=EntityRef.bot_self(), + object=EntityRef.bot_self(), + scope=BOT_PERSONAL_SCOPE, + session_id=BOT_PERSONAL_SESSION_ID, + visibility=BOT_PERSONAL_VISIBILITY, + sayability="indirect", + reality_level=contract["reality_level"], + lifecycle=contract["lifecycle"], + content=bot_personal_content(envelope["memory_type"], body_payload), + evidence="; ".join(envelope["source_refs"]), + confidence=confidence, + importance=importance, + tags=["bot_personal", envelope["memory_type"], contract["source_kind"]], + metadata=metadata, + source_plugin=clean_text(source_plugin, 120) or "private_companion", + occurred_at=envelope["occurred_at"], + ) + result = await self.store.upsert_bot_personal_memory( + record, + payload_fingerprint=payload_fingerprint, + version=envelope["version"], + idempotency_key=envelope["idempotency_key"], + ) + if result.get("action") in {"created", "updated"}: + self._schedule_memory_embedding(record.id, record) + return {**base, "ok": result.get("action") in {"created", "updated", "deduplicated"}, "record_id": result.get("record_id", record_id), "deduplicated": bool(result.get("deduplicated")), "version": int(result.get("version") or envelope["version"]), "error_code": result.get("error_code"), "action": result.get("action")} + except BotPersonalValidationError as exc: + return {**base, "error_code": exc.error_code, "error": exc.message, "field": exc.field} + except Exception as exc: + logger.exception("[MemoryCompanion] Bot Personal 归档失败: %s", exc) + return {**base, "error_code": "internal_error", "error": clean_text(exc, 240)} async def search_bot_personal_memory( self, @@ -931,6 +1031,69 @@ class MemoryCompanionService: and (not allowed_types or record.memory_type in allowed_types) ][: max(1, min(100, int(limit or 10)))] return [serialize_memory(record, reason="bot_personal_profile") for record in selected] + + async def search_bot_personal_profile( + self, + profile: str, + query: str = "", + *, + limit: int | None = None, + now: datetime | None = None, + ) -> dict[str, Any]: + """M6.1.5:按 Profile 检索 Bot 个人记忆。 + + 调用方只能选 Profile 名,允许域/类型/时间范围/条数/排序/注入字段全部由 Profile 固定。 + `limit` 只能往小调,调不大——否则一次调用就能把整个 Profile 的上限突破掉。 + """ + profile_name = clean_text(profile, 80).lower() + try: + spec = get_bot_profile(profile_name) + except BotProfileError as exc: + return {"profile": profile_name, "memories": [], "read_only": True, + "warnings": [exc.error_code]} + moment = now or local_now() + allowed_types = set(spec["memory_types"]) + effective_limit = spec["limit"] if limit is None else max(1, min(int(spec["limit"]), int(limit))) + # 时间窗与类型直接进 SQL:在 Python 里后筛会被「按时间倒序截断」坑掉—— + # 近期记录一多,落在历史窗里的行根本进不了结果集,Profile 会静默返回空。 + earliest, latest = profile_time_bounds(spec, moment) + records = await self.store.list_bot_profile_memories( + memory_domain=BOT_PERSONAL_MEMORY_DOMAIN, + memory_types=sorted(allowed_types), + occurred_from=earliest.isoformat() if earliest else "", + occurred_to=latest.isoformat() if latest else "", + query=clean_text(query, 500), + limit=max(effective_limit * 3, 30), + ) + selected = [ + record for record in records + # 域是硬边界:Profile 永远只读 Bot 域,任何情况下都不返回用户记忆 + if record.memory_domain == BOT_PERSONAL_MEMORY_DOMAIN + and record.memory_type in allowed_types + and record_within_profile_window(record.occurred_at, spec, moment) + ] + selected.sort(key=lambda r: str(r.occurred_at or ""), reverse=spec["order"] == "occurred_at_desc") + # 不走 serialize_memory:它按自己的清单挑字段(且不返回 metadata), + # Profile 需要的 date/window/source_kind/epistemic_type 都在 metadata 里,取不到。 + projected = [ + project_profile_fields({ + "id": record.id, + "memory_type": record.memory_type, + "content": record.content, + "occurred_at": record.occurred_at, + "reality_level": record.reality_level, + "metadata": record.metadata if isinstance(record.metadata, dict) else {}, + }, spec) + for record in selected[:effective_limit] + ] + return { + "profile": profile_name, + "memory_domain": BOT_PERSONAL_MEMORY_DOMAIN, + "read_only": True, + "limit": effective_limit, + "memories": projected, + "warnings": [], + } async def bridge_search( self, query: str, @@ -948,9 +1111,48 @@ class MemoryCompanionService: def bridge_probe_bot_personal_memory_capabilities(self) -> dict[str, Any]: return { "available": True, + "write_enabled": self.config.bool("private_companion_bridge.accept_external_records", True), "read_only": False, "memory_domain": BOT_PERSONAL_MEMORY_DOMAIN, "accepted_memory_types": sorted(BOT_PERSONAL_MEMORY_TYPES), + "dedicated_methods": [ + "record_bot_schedule_plan", + "record_bot_observed_activity", + "record_bot_schedule_reconciliation", + "record_bot_window_snapshot", + "record_bot_daily_diary", + ], + "compatibility_methods": [ + "record_bot_personal_memory", + "record_bot_creative_work", + "record_bot_media_memory", + "record_bot_subjective_memory", + "record_bot_shared_activity", + "record_bot_detail_fragment", + "record_bot_calendar_event", + "record_bot_proactive_message", + ], + # M6.1.5:把 Profile 契约原样暴露出去,调用方不必猜测类型/时间窗/条数上限 + "retrieval_profiles": describe_bot_profiles(), + "retrieval_methods": [ + "search_bot_personal_profile", + "search_bot_schedule", + "search_bot_creative_memory", + "search_bot_subjective_memory", + "search_locked_frame_personal_memory", + ], + "capability_schema_version": BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION, + "payload_schema_version": BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION, + "max_payload_bytes": BOT_PERSONAL_MAX_PAYLOAD_BYTES, + "error_codes": [ + "bridge_method_unavailable", "invalid_bridge_response", "bridge_write_disabled", + "invalid_memory_type", "invalid_payload", "invalid_field", "payload_too_large", + "privacy_rejected", "invalid_date", "invalid_window", "invalid_occurred_at", + "missing_source_refs", "missing_occurred_at", "missing_date", "missing_window", + "invalid_certainty", "invalid_evidence_level", "invalid_version", + "missing_idempotency_key", "unsupported_payload_schema", "stale_version", + "version_conflict", "idempotency_conflict", "domain_conflict", "internal_error", + ], "four_window_schedule": True, "daily_diary": True, "idempotent_writes": True, @@ -2432,7 +2634,7 @@ class MemoryCompanionService: error: str = "", ) -> None: usage = self._extract_token_usage(resp, prompt, completion) - now_dt = datetime.now() + now_dt = local_now() now_ts = time.time() day = now_dt.strftime("%Y-%m-%d") hour = now_dt.strftime("%Y-%m-%dT%H:00") @@ -7087,7 +7289,7 @@ class MemoryCompanionService: if not check_like: return False try: - hour = datetime.now().hour + hour = local_now().hour except Exception: return True return hour >= 23 or hour < 7 @@ -7606,7 +7808,7 @@ class MemoryCompanionService: def _compute_time_of_day(self) -> str: """Compute time-of-day category for atmosphere hints.""" try: - hour = datetime.now().hour + hour = local_now().hour except Exception: return "" if 23 <= hour or hour < 4: diff --git a/core/store.py b/core/store.py index 3e0ce99..216f92c 100644 --- a/core/store.py +++ b/core/store.py @@ -107,8 +107,9 @@ class MemoryStore: if self._conn.in_transaction: self._conn.rollback() self._recover_connection_sync() + result = operation(*args) self._database_recovery_successes += 1 - return operation(*args) + return result async def _run_recoverable_database_operation(self, operation: Any, *args: Any) -> Any: return await asyncio.to_thread(self._run_with_database_recovery_sync, operation, *args) @@ -499,6 +500,13 @@ class MemoryStore: self._conn.execute( "CREATE INDEX IF NOT EXISTS idx_memories_fingerprint ON memories(content_fingerprint)" ) + # M6.1.4:创作/媒体/主观等 Bot 个人类型按「类型 + 时间」回溯, + # idx_memories_domain 的前缀是 (domain, lifecycle, scope, ...),用不上 memory_type, + # 这类查询只能退化成域内全扫。 + self._conn.execute( + "CREATE INDEX IF NOT EXISTS idx_memories_domain_type_time " + "ON memories(memory_domain, memory_type, occurred_at DESC)" + ) self._conn.execute( "CREATE INDEX IF NOT EXISTS idx_timeline_summary ON timeline(session_id, summarized_at, occurred_at)" ) @@ -1333,6 +1341,80 @@ class MemoryStore: self._conn.commit() return record.id + async def upsert_bot_personal_memory( + self, + record: MemoryRecord, + *, + payload_fingerprint: str, + version: int, + idempotency_key: str, + ) -> dict[str, Any]: + return await self._run_recoverable_database_operation( + self._upsert_bot_personal_memory_sync, + record, + payload_fingerprint, + version, + idempotency_key, + ) + + def _upsert_bot_personal_memory_sync( + self, + record: MemoryRecord, + payload_fingerprint: str, + version: int, + idempotency_key: str, + ) -> dict[str, Any]: + record.ensure_defaults() + record.updated_at = utc_now() + data = record.to_db() + metadata = dict(record.metadata or {}) + metadata["payload_fingerprint"] = clean_text(payload_fingerprint, 80) + metadata["version"] = int(version) + metadata["idempotency_key"] = clean_text(idempotency_key, 240) + record.metadata = metadata + data["metadata"] = json_dumps(metadata) + with self._lock: + row = self._conn.execute("SELECT * FROM memories WHERE id=?", (record.id,)).fetchone() + if row is None: + columns = ", ".join(data.keys()) + placeholders = ", ".join(f":{key}" for key in data.keys()) + self._conn.execute(f"INSERT INTO memories ({columns}) VALUES ({placeholders})", data) + self._upsert_memory_fts_row(self._conn.execute("SELECT * FROM memories WHERE id=?", (record.id,)).fetchone()) + self._conn.commit() + return {"record_id": record.id, "deduplicated": False, "version": int(version), "action": "created"} + stored = MemoryRecord.from_row(row) + stored_metadata = dict(stored.metadata or {}) + stored_domain = clean_text(stored.memory_domain, 80) + if stored_domain != "bot_self_schedule": + return {"record_id": record.id, "deduplicated": False, "version": int(stored_metadata.get("version") or 0), "action": "error", "error_code": "domain_conflict"} + stored_key = clean_text(stored_metadata.get("idempotency_key"), 240) + if stored_key and stored_key != clean_text(idempotency_key, 240): + return {"record_id": record.id, "deduplicated": False, "version": int(stored_metadata.get("version") or 0), "action": "error", "error_code": "idempotency_conflict"} + stored_version = int(stored_metadata.get("version") or 1) + stored_fingerprint = clean_text(stored_metadata.get("payload_fingerprint"), 80) + incoming_fingerprint = clean_text(payload_fingerprint, 80) + if int(version) < stored_version: + return {"record_id": record.id, "deduplicated": False, "version": stored_version, "action": "error", "error_code": "stale_version"} + if int(version) == stored_version: + if stored_fingerprint == incoming_fingerprint: + return {"record_id": record.id, "deduplicated": True, "version": stored_version, "action": "deduplicated"} + return {"record_id": record.id, "deduplicated": False, "version": stored_version, "action": "error", "error_code": "version_conflict"} + history = stored_metadata.get("version_history") + if not isinstance(history, list): + history = [] + history.append({"version": stored_version, "payload_fingerprint": stored_fingerprint, "updated_at": stored.updated_at}) + metadata["version_history"] = history[-8:] + record.created_at = stored.created_at + record.metadata = metadata + data = record.to_db() + data["created_at"] = stored.created_at + data["updated_at"] = utc_now() + assignments = ", ".join(f"{key}=:{key}" for key in data if key != "id" and key != "created_at") + self._conn.execute(f"UPDATE memories SET {assignments} WHERE id=:id", data) + self._upsert_memory_fts_row(self._conn.execute("SELECT * FROM memories WHERE id=?", (record.id,)).fetchone()) + self._conn.commit() + return {"record_id": record.id, "deduplicated": False, "version": int(version), "action": "updated"} + def _upsert_review_sync(self, memory_id: str, reason: str) -> None: now = utc_now() self._conn.execute( @@ -3864,8 +3946,8 @@ class MemoryStore: params.append(clean_text(group_id, 120)) if entity_id: entity = clean_text(entity_id, 120) - where += " AND (subject_id=? OR object_id=? OR group_id=? OR session_id LIKE ?)" - params.extend([entity, entity, entity, f"%{entity}%"]) + where += " AND (subject_id=? OR object_id=? OR group_id=? OR session_id LIKE ? ESCAPE '\\')" + params.extend([entity, entity, entity, self._like_pattern(entity)]) with self._lock: rows = self._conn.execute( f""" @@ -3878,6 +3960,66 @@ class MemoryStore: ).fetchall() return [MemoryRecord.from_row(row) for row in rows] + async def list_bot_profile_memories( + self, + *, + memory_domain: str, + memory_types: list[str], + occurred_from: str = "", + occurred_to: str = "", + query: str = "", + limit: int = 10, + ) -> list[MemoryRecord]: + """M6.1.5:按 Profile 约束直接在 SQL 里筛。 + + 不能复用 list_memories 再在 Python 里过滤——它按 occurred_at DESC 截断, + 近期记录一多,落在历史时间窗里的行根本进不了结果集,Profile 会静默返回空。 + 走 idx_memories_domain_type_time。 + """ + return await self._run_recoverable_database_operation( + self._list_bot_profile_memories_sync, + clean_text(memory_domain, 60), + [clean_text(item, 80) for item in (memory_types or []) if clean_text(item, 80)], + clean_text(occurred_from, 80), + clean_text(occurred_to, 80), + clean_text(query, 500), + max(1, min(200, int(limit or 10))), + ) + + def _list_bot_profile_memories_sync( + self, + memory_domain: str, + memory_types: list[str], + occurred_from: str, + occurred_to: str, + query: str, + limit: int, + ) -> list[MemoryRecord]: + if not memory_domain or not memory_types: + return [] + params: list[Any] = [memory_domain] + where = "memory_domain=? AND review_status != 'pending'" + where += f" AND memory_type IN ({','.join('?' * len(memory_types))})" + params.extend(memory_types) + # occurred_at 是 ISO-8601 带偏移的字符串,同一时区下字典序即时间序; + # 边界比较只用于粗筛,精确判定仍由 record_within_profile_window 完成。 + if occurred_from: + where += " AND occurred_at >= ?" + params.append(occurred_from) + if occurred_to: + where += " AND occurred_at <= ?" + params.append(occurred_to) + if query: + like = f"%{query}%" + where += " AND (content LIKE ? OR evidence LIKE ?)" + params.extend([like, like]) + with self._lock: + rows = self._conn.execute( + f"SELECT * FROM memories WHERE {where} ORDER BY occurred_at DESC, created_at DESC LIMIT ?", + (*params, limit), + ).fetchall() + return [MemoryRecord.from_row(row) for row in rows] + async def list_memory_buckets(self, limit: int = 160) -> list[dict[str, Any]]: return await asyncio.to_thread(self._list_memory_buckets_sync, limit) diff --git a/core/temporal_context.py b/core/temporal_context.py index d161306..f2166b9 100644 --- a/core/temporal_context.py +++ b/core/temporal_context.py @@ -23,6 +23,18 @@ LONG_TERM_TYPES = { } +def local_now(*, timezone_name: str = DEFAULT_TIMEZONE) -> datetime: + """记忆侧统一的“当前本地时间”。 + + 必须带时区:容器 TZ 为 UTC 时,naive `datetime.now()` 会让时段判定和 + token 分桶相对配置时区偏 8 小时。 + """ + try: + return datetime.now(ZoneInfo(timezone_name or DEFAULT_TIMEZONE)) + except Exception: + return datetime.now(LOCAL_TZ) + + def _parse_datetime(value: Any, *, timezone_name: str = DEFAULT_TIMEZONE) -> datetime | None: text = clean_text(value, 120) if not text: diff --git a/core/user_memory_boundary.py b/core/user_memory_boundary.py index a251d2a..2c9a8a6 100644 --- a/core/user_memory_boundary.py +++ b/core/user_memory_boundary.py @@ -2,7 +2,14 @@ from __future__ import annotations from typing import Any -from .models import MemoryRecord, clean_text +from .models import ( + BOT_SELF_MEMORY_TYPES, + BOT_SELF_REALITY_LEVELS, + USER_MEMORY_TYPES, + USER_MEMORY_WRITE_BLOCKED_TYPES, + MemoryRecord, + clean_text, +) USER_MEMORY_DOMAIN = "user_memory" BOT_SELF_LEGACY_DOMAIN = "bot_self_legacy" @@ -10,35 +17,22 @@ MIXED_MEMORY_DOMAIN = "shared_or_mixed" UNKNOWN_MEMORY_DOMAIN = "unknown" CALENDAR_HISTORY_DOMAIN = "calendar_history" -USER_MEMORY_TYPES = frozenset({ - "user_fact", - "user_event", - "user_decision", - "user_summary", - "user_profile", - "user_preference", - "user_habit", - "relationship_claim", - "explicit_memory", - "manual_memory", - "conversation_event", - "conversation_summary", - "important_event", - "daily_digest", - "tool_memory", -}) -BOT_SELF_MEMORY_TYPES = frozenset({ - "self_action", - "persona_life", - "proactive_message", - "schedule_fragment", - "companion_note", - "calendar_event", - "agenda_snapshot", - "timeline_event", - "memory_decay_summary", -}) -BOT_SELF_REALITY_LEVELS = frozenset({"bot_action", "persona_life", "llm_tool_assertion"}) +# 类型/真实性集合的定义在 `core/models.py`,此处只做再导出, +# 保证域判定与写入门禁只有一份来源(详见 models.py 注释)。 +__all__ = [ + "USER_MEMORY_DOMAIN", + "BOT_SELF_LEGACY_DOMAIN", + "MIXED_MEMORY_DOMAIN", + "UNKNOWN_MEMORY_DOMAIN", + "CALENDAR_HISTORY_DOMAIN", + "USER_MEMORY_TYPES", + "BOT_SELF_MEMORY_TYPES", + "BOT_SELF_REALITY_LEVELS", + "USER_MEMORY_WRITE_BLOCKED_TYPES", + "UserMemoryBoundaryError", + "infer_memory_domain", + "validate_user_memory_record", +] class UserMemoryBoundaryError(ValueError): @@ -75,7 +69,7 @@ def validate_user_memory_record(record: MemoryRecord, *, require_evidence: bool raise UserMemoryBoundaryError("missing_group_id") if clean_text(record.visibility, 40).lower() == "bot_self": raise UserMemoryBoundaryError("bot_self_visibility") - if clean_text(record.memory_type, 80).lower() in BOT_SELF_MEMORY_TYPES: + if clean_text(record.memory_type, 80).lower() in USER_MEMORY_WRITE_BLOCKED_TYPES: raise UserMemoryBoundaryError(f"bot_self_memory_type:{record.memory_type}") if clean_text(record.reality_level, 80).lower() in BOT_SELF_REALITY_LEVELS: raise UserMemoryBoundaryError(f"bot_self_reality_level:{record.reality_level}") diff --git a/docs/运维记忆错题本.md b/docs/运维记忆错题本.md index 524dfc9..a2f3d7e 100644 --- a/docs/运维记忆错题本.md +++ b/docs/运维记忆错题本.md @@ -155,3 +155,136 @@ - 修复或规避:新增 Bot 个人类型白名单和显式 Bridge 包装;默认检索继续阻止 Bot 域;Locked Frame 只读页面只接收 Bot 个人域或陪伴旧本地记录;远端 Bridge 失败时不阻断陪伴侧本地写入。 - 预防规则:任何 Bot 自身日程读取必须显式使用 Bot personal profile;页面、Bridge、服务三层都要检查域、主体、可见性和来源,不能只看标签。 - 验证证据:M6_MEMORY_TESTS_OK;compileall -q core tests page_api.py;git diff --check;专用 Bridge、幂等写入、默认检索隔离和观察窗分类已复核。 + +## 2026-07-26 — Bot Personal 独立域不等于真实性、幂等和只读合同完成 + +- 阶段:M6.1.1~M6.1.6 源码复盘 +- 类型:API契约 / 数据隔离 / 功能行为 +- 现象:`bot_self_schedule` 已独立,但 `bot_schedule_plan` 被统一写成 observed/bot_action;记录 ID 同时包含幂等键和 payload,同键不同载荷会产生新 ID;Locked Frame 仍依赖陪伴插件私有运行对象。 +- 根因:Bot Personal 只完成类型和域骨架,尚未按类型定义真实性、字段必填、稳定 ID、版本竞争、专用 Profile 和纯归档只读 API。 +- 修复或规避:先冻结按类型合同和稳定幂等 ID,加入版本比较与递归白名单清洗;再实现 current/history/creative/subjective/locked-frame Profiles 和分层只读 API。 +- 预防规则:能力探测返回 `idempotent_writes=true` 前必须覆盖“同键不同 payload”和乱序版本测试;计划永远不能沿用 observed/bot_action 默认值。 +- 验证证据:`core/service.py:867`、`core/store.py:1213`、`core/bot_personal.py:28`、`page_api.py:1229`、`docs/OPS双插件完整复盘与功能调整总方案.md`。 +## 2026-07-26 — M6.1.3-A Bot 归档可靠写入合同 + +- 阶段:M6.1.3-A 记忆侧归档合同、可靠幂等写入和五类 Bridge +- 类型:API契约 / 数据隔离 / 测试 +- 现象:旧 Bot Personal 写入把 payload 拼入 record_id、所有类型统一映射为 bot_action,通用 SQLite UPSERT 可静默覆盖乱序版本,递归隐私清洗也会静默丢弃字段。 +- 根因:此前只有逻辑域和类型骨架,没有独立的 envelope 校验、版本竞争和 Bot 专用原子写入路径。 +- 修复或规避:冻结 capability/payload schema 1.0;record_id 只由域、类型和幂等键生成;新增同键去重、新版本更新、旧版本拒绝和同版本冲突;五类类型固化真实性;递归拒绝敏感字段、完整聊天、凭据、Base64、媒体二进制和本机路径;写入强制 bot_self_schedule 与 bot_self。 +- 预防规则:任何 Bridge 能力只有在返回合同、错误码、版本竞争和隐私拒绝均有测试后才可声明 FROZEN;计划不得复用 observed/bot_action 默认值。 +- 验证证据:M6.1.3-A 定向 9 项通过;OPS 纯测试 143 项通过;compileall 通过;git diff --check 通过;共享合同已更新为 FROZEN。 + +## 2026-07-26 — M6.1.3-R1 联合审查阻断修复 + +- 阶段:R1 记忆侧严格字段、canonical fingerprint、超限拒绝和兼容回归 +- 类型:API契约 / 数据隔离 / 测试 +- 现象:联合审查复现出非法日期、非法窗口、无时区时间可写入;20KB 字符串被静默截断;fingerprint 未覆盖 Envelope;plan 允许非 L0;旧 creative/media/subjective/shared 类型会落入 observed;部分运行错误码未声明。 +- 根因:第一版只完成 Bot 域和幂等骨架,没有把 FROZEN Envelope 的所有语义字段统一送入验证与 canonical fingerprint,非五类类型也使用了过宽默认合同。 +- 修复或规避:增加严格日期/窗口/时区解析;原始 JSON payload 先验大小再清洗;fingerprint 覆盖 payload、日期、窗口、发生时间、来源、确定性、证据等级、状态、版本、幂等键、schema 和 source_kind;plan 强制 L0;非五类恢复显式真实性和兼容 wrapper;错误码与 capability/共享合同同步。 +- 预防规则:FROZEN 合同的每个落库语义字段都必须有单独变化冲突测试;任何清洗前截断都视为数据完整性风险;旧能力不能用 observed 兜底。 +- 验证证据:R1 定向 15 项通过;OPS 纯测试 143 项通过;compileall 和 git diff --check 通过;共享合同字段规范仍为 FROZEN 1.0,实施验收保持 REOPEN_REQUIRED。 + +## 2026-07-26 — 兼容回归不能只用喂满 Envelope 的夹具 + +- 阶段:M6.1.3-R1 联合复验 +- 类型:API契约 / 测试 / 数据隔离 +- 现象:R1 七项必修全部通过联合复验(严格时间、完整 fingerprint、超限拒绝、L0 规则、错误码覆盖、专用/通用一致);但“非五类兼容”测试因夹具恒带 date/window/occurred_at 而全绿,真实陪伴 DTO(date 为空)在联合链路上被 `invalid_date` 拒绝,5 个旧 kind 归档中断。 +- 根因:`envelope_payload` 夹具验证的是提供方视角的兼容,没有覆盖调用方真实 DTO 形状;另值级隐私清洗缺 `base64,`/`data:` URI 与路径中缀检测,弱于陪伴侧(纵深防御缺口)。 +- 修复或规避:M6.1.3-R2——补“date 由 occurred_at 派生”的真实形状兼容回归(date 为空仍必须 invalid_date,不放松校验,主修在陪伴侧);`_FORBIDDEN_VALUE_PATTERNS` 增加 base64/data URI 与中缀路径模式并配正反例。 +- 预防规则:对外兼容能力的回归必须包含调用方真实序列化输出样本;声明“禁止 Base64/本机路径”的合同必须有对应值级检测与测试,不能只依赖键名黑名单和上游拦截。 +- 验证证据:`docs/M6.1.3双插件真实联合验收报告-R1复验.md` P1-R2-1、P2-1;联合 E2E L 组与 P 组扫描。 + +## 2026-07-26 — 审计 Batch 1:报告的 B21 症状与源码不符,域判定集合被当成写入门禁 + +- 阶段:OPS 源码审计整改 Batch 1(B12、B21、B23、B13) +- 类型:API契约 / 数据隔离 / 测试 +- 现象:审计报告 B21 断言「`ensure_defaults` 缺 `memory_decay_summary`,衰减总结被判成 `user_memory`」。回读 `core/models.py:100` 发现 `memory_domain` 字段默认值是 `"unknown"`(真值),而 `ensure_defaults` 的分类分支写的是 `if not self.memory_domain:`,因此该分支**只在调用方显式传 `memory_domain=""` 时才执行**;`core/service.py:4269` 的衰减总结没有传域,落库实际是 `unknown`,被 `_memory_domain_block_reason` 判为 `missing_user_subject`,从来没有被判成 `user_memory`。 +- 根因:`user_memory_boundary.BOT_SELF_MEMORY_TYPES` 同时承担两件互相冲突的事——① 域判定(`infer_memory_domain`)② 用户记忆 Bridge 的写入门禁。`memory_decay_summary` 只应属于 ②;把它塞进同一个集合,才导致「models 的内联清单」与「boundary 的清单」看起来漂移。三个分类器里 `models.ensure_defaults` 与 `user_memory_migration._classify:104` 都判用户域,只有 `infer_memory_domain` 判 `bot_self_legacy`,少数派才是需要拆分的那一个。 +- 修复或规避:域判定的三个集合下沉到 `core/models.py`(最底层模块,避免 models ←→ user_memory_boundary 循环导入),由 `user_memory_boundary` 再导出,两个分类器共用同一个 frozenset 对象;新增 `USER_MEMORY_WRITE_BLOCKED_TYPES = BOT_SELF_MEMORY_TYPES | {"memory_decay_summary"}` 专供 `validate_user_memory_record` 的写入门禁,拒绝行为与错误码 `bot_self_memory_type:memory_decay_summary` 保持不变。**未按报告字面把衰减总结改判 `bot_self_legacy`**:那样会让默认开启(`memory_decay_enabled` default true)的睡眠衰减在压缩后既归档原片段、又屏蔽总结,等于把记忆从召回面彻底抹掉。 +- 预防规则:① 报告给出的「症状」必须先用源码复现再动手,dataclass 默认值为真值时 `if not field:` 分支可能是事实上的死分支;② 一个常量集合只能服务一个语义,域判定与写入门禁必须分开命名;③ 收紧写入门禁允许,放宽不允许——改动后必须有「同一条记录仍被拒绝且错误码不变」的用例;④ 任何会改变 `memory_domain` 归类的改动,都要先算「检索是否还召回得到」,压缩/归档链路上的域变更等同数据可用性变更。 +- 遗留(新发现,未在本批修):衰减总结当前落库域为 `unknown`,检索前置过滤直接屏蔽,而源片段已被 `archive_memories` 归档(`lifecycle=archived` 被候选查询排除),因此**睡眠衰减压缩后的内容在主线检索中不可召回**。这是 B10(域放行意图)同一类问题,需与 B10 一起确认产品意图后处理。 +- 验证证据:`tests/test_audit_batch1_fixes.py::MemoryDomainConstantSourceTests`(6 项:常量同一对象、`ensure_defaults` 不再内联清单、两分类器一致、衰减总结域一致、写入门禁仍拒绝且错误码不变、默认值陷阱固化);OPS 纯测试 198 项通过;联合 E2E 85/81/4 与 R1 基线失败集合完全一致。 + +## 2026-07-26 — 审计 Batch 1:未转义 LIKE、恢复计数与记忆侧 naive 时钟 + +- 阶段:OPS 源码审计整改 Batch 1 +- 类型:数据隔离 / 可观测性 / 时间感知 +- 现象: + - B12 `core/store.py:3941`:`list_memories(entity_id=...)` 用 `f"%{entity}%"` 裸 LIKE。实测 `entity_id="u_1"` 会同时命中 `qq:FriendMessage:uX1`(`_` 被当成单字符通配),跨会话串记忆。 + - B23 `core/store.py:110`:`_database_recovery_successes += 1` 写在 `return operation(*args)` 之前,恢复后重试再次失败也计为成功,`wal_health` 的恢复成功率指标失真。 + - B13 `core/service.py:2548/7203/7722`:时段判定与 token 分桶用 naive `datetime.now()`,UTC 容器上相对全局 `Asia/Shanghai` 偏 8 小时,`by_day`/`by_hour` 键和「深夜查岗」判定都会错档。 +- 根因:同文件已有 `_like_pattern`/`_like_id` 转义工具但该处漏用;计数语义把「已尝试恢复」当成「恢复成功」;记忆侧没有统一的「当前本地时间」入口,各处各写。 +- 修复或规避:B12 改 `session_id LIKE ? ESCAPE '\'` + `self._like_pattern(entity)`;B23 先 `result = operation(*args)` 成功后再自增;B13 在 `core/temporal_context.py` 新增公共 `local_now(timezone_name=DEFAULT_TIMEZONE)`(带时区、非法时区回落 `Asia/Shanghai`),三处调用点统一改走它。 +- 预防规则:① 任何 LIKE 都必须走转义 helper 并显式带 `ESCAPE`,禁止裸 `%{value}%`;② 成功类计数器只能在被计数的操作真正返回之后自增;③ 记忆侧禁止 naive `datetime.now()`,一律走 `local_now()` 或显式 tz,并用 AST 扫描把这条规则钉死在测试里。 +- 验证证据:`tests/test_audit_batch1_fixes.py` 的 `EntityLikeEscapeTests`(3 项,含 `_`/`%` 反例与正常 ID 正例)、`DatabaseRecoveryCounterTests`(3 项,含二次失败不计数、成功只计一次、非路径错误不动计数器)、`MemorySideTimezoneTests`(5 项,含 AST 扫描 `core/*.py`+`page_api.py`+`main.py` 无 naive `datetime.now()`);改前/改后 SQL 对照已实测(改前返回 `mem_neighbor`+`mem_underscore`,改后只返回 `mem_underscore`)。 + +## 2026-07-26 — 记忆纯测试的 181 项只有 pytest 能收齐 + +- 阶段:审计 Batch 1 回归基线 +- 类型:测试 / 环境 +- 现象:优化方案 README 写「记忆纯测试(现 181 项)」,但 `python -m unittest` 按模块跑只有 143 项,容易被误判为「测试少了 38 项」。 +- 根因:`tests/test_archive_contract.py`、`test_bot_personal_memory.py`、`test_q6_user_fact_bridge.py`、`test_temporal_context.py` 用的是模块级 `test_*` 函数,`unittest` 只收集 `TestCase` 子类,收不到这些函数。 +- 修复或规避:以 pytest 收集数为纯测试口径,命令固定为 `python -m pytest -q --ignore=tests/test_security_cache.py`(`test_security_cache` 导入普通陪伴分支且本机无 AstrBot 宿主包,属环境阻塞不是业务回归);需要 unittest 口径时另记 `TestCase` 计数。 +- 预防规则:报告里的测试项数必须写清收集器;换收集器前后的数字不可直接相减当成回归。 +- 验证证据:本轮基线 pytest 181 项通过 / unittest 143 项通过;补测后 pytest 198 项通过 / unittest 160 项通过。 + +## 2026-07-26 — 值级隐私模式锚定行首,等于只防了「整条就是路径」 + +- 阶段:M6.1.3-R2 记忆侧防御加固(M2) +- 类型:隐私 / API契约 / 测试 +- 现象:`_FORBIDDEN_VALUE_PATTERNS` 的路径模式写成 `^(?:[A-Za-z]:[\/]|/|\\)`,只有「整个字符串就是一条路径」才拦得住。实测 8 类真实写法全部漏过:`data:image/png;base64,...`、`封面图 base64,xxx`、`照片保存在 D:\private\a.png 了`、`\nas\share`、`/home/`、`/tmp/`、`/volume1/`、`-----BEGIN RSA PRIVATE KEY-----`。合同第 130 行明写禁止 Base64、媒体二进制和任意本机绝对路径,所以这不是纵深防御的可选项,是合同缺口。 +- 根因:写模式时脑子里的样本是「字段值 = 路径」,而真实 payload 里路径几乎总是嵌在中文句子中间。另一边陪伴侧 `_looks_sensitive_value()` 早就用了 `(?:^|[\s=])` 中缀写法,两侧从未对照过。 +- 修复或规避:保留原前缀模式(本侧 `^/` 比陪伴侧更严,不能退),新增中缀路径、`base64,`、`data:` URI、`-----begin ` 四条,与陪伴侧对齐。`clean_text()` 在匹配前已把空白折叠成单空格,因此 `(?:^|[\s=])` 不存在换行绕过。全部复用 `privacy_rejected`,capability 的 25 码清单无需变动。 +- 预防规则:值级敏感检测一律按「嵌在自然语言里」设计,禁止只写 `^` 锚定;双方各有一份检测规则时,要有一个直接对照两份规则的用例,而不是各自测各自的。误杀同样要钉死:正常中文句子、`docs/a.md`、`./x`、`https://` 必须有反例测试。 +- 验证证据:`tests/test_m6_r2_real_dto_shape.py` 14 条正例(全部 `privacy_rejected`)+ 9 条反例(全部写入成功);逐条对比 R1 四模式与 R2 八模式,8 类漏检全部转为拦截,正常文本仍不误杀;记忆侧 243 项、联合 E2E 90 项通过。 + +## 2026-07-26 — 兼容回归要用调用方真实序列化输出,不是自造夹具(执行记录) + +- 阶段:M6.1.3-R2 记忆侧回归(M1) +- 类型:测试 / API契约 +- 现象:承接上一条同名预防规则。本轮落地时确认,本仓 `tests/test_bot_personal_memory.py` 的 `envelope_payload()` 恒在 payload 里塞满 date/window/occurred_at,而陪伴真实 DTO 是「信封字段走 kwarg、body 里根本没有 date」的两层结构;两种形状连字段位置都不同,自造夹具再全也测不到真实链路。另外 `test_non_five_legacy_types_keep_explicit_truth_mapping` 只覆盖 6 类,`bot_calendar_event` 从未被测过——而它正是 E2E L 组失败的五个 kind 之一。 +- 根因:提供方写兼容测试时按自己的 API 签名造夹具,没有拿调用方的实际输出做样本。 +- 修复或规避:新增 `tests/test_m6_r2_real_dto_shape.py`:能拿到陪伴仓时直接 import 它真实的 `build_bot_personal_dto`(该模块只依赖标准库,可独立载入)跑 7 类;拿不到时退回逐字复刻的真实形状样本,两条路径都保证 body 里没有 date。补齐 `bot_calendar_event`,并加一条断言把覆盖集合钉在 `BOT_PERSONAL_TYPE_CONTRACTS` 减严格五类上,防止以后新增类型漏测。 +- 预防规则:跨插件兼容回归必须包含调用方真实序列化输出样本;「覆盖了哪几类」这种事要用集合断言钉住,不能靠人肉核对清单。 +- 验证证据:`tests/test_m6_r2_real_dto_shape.py` 45 项通过(含 7 类真实 DTO + 7 类复刻样本 + calendar_event 专项 + date 空/非法/naive occurred_at 三条「不放松校验」);记忆侧总计 243 项通过,`compileall` 通过。 + +## 2026-07-27 — 滚动升级窗口里,payload 形状变化就是一次静默数据丢失 + +- 阶段:M6.1.4 分域与形状归一 +- 类型:API契约 / 部署 / 测试 +- 现象:陪伴侧把非五类的通用回退从「整包送 envelope」改成「送 body」。两种形状剥离信封字段后内容其实等价,但指纹不同——整包形状剥完只剩 `{"payload": {...}}`,body 形状剥完是 `{...}`。双插件是分别部署的(M6.1.8 明确先记忆后陪伴),升级窗口里同一条记录会先后以两种形状到达,第二次必然 `version_conflict` → 永久错 → 死信。另外发现 `created_at`/`updated_at` 不在剥离清单里,它们随墙钟漂移,同一条记录隔一小时重投就变 `version_conflict`。 +- 根因:剥离清单是按「验证需要哪些字段」列的,不是按「哪些是信封字段」列的,于是漏了一批只在整包形状下才会出现的键。归一化顺序也有坑:必须**先解包再剥离**,反过来内层的 `source_refs` 会留在 body 里,两种形状仍然对不上。 +- 修复或规避:提取 `BOT_PERSONAL_ENVELOPE_KEYS`(17 个)作为唯一事实源;`record_bot_personal_memory` 先判断「除 payload 外全是信封字段」再解包,然后统一剥离。两种形状因此产生同一个指纹,旧版陪伴仍可写入。 +- 预防规则:接收方的兼容性不能只保证「旧形状不报错」,还要保证「旧形状与新形状指纹一致」——否则升级窗口里的重投会被当成内容冲突。凡是分别部署的两个组件,改动线上载荷形状时必须补一条「新旧形状互认」的回归。 +- 验证证据:`tests/test_m6_r2_real_dto_shape.py::test_whole_envelope_shape_stays_backward_compatible`(两种形状 → `deduplicated`)与 `test_envelope_timestamps_do_not_drift_the_fingerprint`;联合 E2E 101 项全通过。 + +## 2026-07-27 — 域索引的前缀顺序决定了它对分类型检索毫无用处 + +- 阶段:M6.1.4 创作/媒体/主观独立索引 +- 类型:性能 / 数据模型 +- 现象:`idx_memories_domain` 是 `(memory_domain, lifecycle, scope, group_id, subject_id)`。而创作/媒体/主观的检索形态是「域内按 `memory_type` 过滤、按时间倒序取最近若干条」,`memory_type` 不在索引前缀里,这类查询只能退化成域内全扫描。索引存在,但对这条路径完全用不上。 +- 根因:索引是按「Bot 域 vs 用户域」的隔离需求建的,没有按后续 Profile 检索的实际形态复核过;有索引这件事本身容易让人以为已经覆盖。 +- 修复或规避:新增 `idx_memories_domain_type_time (memory_domain, memory_type, occurred_at DESC)`,匹配「域 + 类型 + 时间倒序」这一形态。M6.1.5 的 Bot Profiles 全部走这条。 +- 预防规则:加索引前先写出目标查询的 WHERE + ORDER BY,再对照索引前缀逐列核;「表上已经有索引」不能作为「这条查询走了索引」的证据。 +- 验证证据:`tests/test_m6_r4_creative_media_domain.py::test_domain_type_time_index_exists` 与分类型过滤三项。 + +## 2026-07-27 — 「先按时间倒序取 N 条,再在内存里筛时间窗」等于把历史查询废掉 + +- 阶段:M6.1.5 Bot 专用检索 Profiles +- 类型:数据模型 / 性能 / 测试 +- 现象:`bot_schedule_history` 上线即静默返回空。实现是 `list_memories(limit=N)` 再在 Python 里按时间窗过滤,而 `list_memories` 本身按 `occurred_at DESC` 排序截断——只要近期记录够多,落在「1 到 90 天前」这个窗口里的行根本进不了那 N 条结果集。单元测试里数据少,怎么测都是对的;联合 E2E 因为前面各组已经积累了大量当天记录,一跑就空。 +- 根因:把「范围约束」和「取前 N 条」的顺序搞反了。SQL 的 LIMIT 作用在排序之后,任何写在 Python 里的后置过滤都是在一个已经被截断的集合上做的。 +- 修复或规避:新增 `list_bot_profile_memories()`,把域、类型、`occurred_at` 区间全部放进 WHERE,走 M6.1.4 建的 `idx_memories_domain_type_time`;Python 侧只保留精确边界判定。补 `test_many_recent_records_do_not_starve_the_history_profile`(60 条当天记录 + 1 条三天前)钉死。 +- 预防规则:凡是「过滤条件 + LIMIT」的查询,过滤必须进 SQL;在内存里后筛只有在「先取全量」时才等价。这类 bug 在小数据集上永远测不出来,回归用例必须显式构造「近期记录远多于 limit」的场景。 +- 验证证据:`tests/test_m6_r5_bot_profiles.py` 28 项;联合 E2E S 组「历史 Profile 只给过去内容,不含当天」。 + +## 2026-07-27 — 检索 Profile 的价值全在「调用方改不了」 + +- 阶段:M6.1.5 Profile 契约 +- 类型:API契约 / 隐私 +- 现象:改造前只有一个 `search_bot_personal_memory(query, limit, memory_types)`,类型和条数都由调用方传。陪伴侧的用法是一次性传 11 个类型、limit 5——所谓「Bot 专用检索」实质就是一次全库通用检索,当前状态和历史记忆混在同一批结果里返回。 +- 根因:把 Profile 理解成「一组默认参数」,而不是「一份调用方改不了的契约」。只要类型、时间窗、条数任意一项可以被调用方覆盖,专用检索就会退化回通用检索。 +- 修复或规避:`core/bot_profiles.py` 把七件事(域/类型/时间范围/条数/排序/注入字段/权限)全部固定在记忆侧;调用方只能选 Profile 名,`limit` 只能往小调不能往大调;注入字段走白名单投影,`serialize_memory` 带出的人格权重、指纹、幂等键一律不出现在结果里;capability 公布契约,两侧不必各自猜测限制。 +- 预防规则:给出「专用入口」时,先列清楚哪些维度必须由提供方固定;每个维度都要有一条「调用方试图突破 → 被夹住」的测试,否则契约只是文档里的一句话。 +- 验证证据:`test_every_profile_pins_all_seven_dimensions`、`test_limit_can_be_lowered_but_not_raised`、`test_projection_drops_internal_fields`、`test_profiles_never_return_user_memories`;联合 E2E S 组 13 项。 diff --git a/docs/错题本.md b/docs/错题本.md index e605378..c81fb96 100644 --- a/docs/错题本.md +++ b/docs/错题本.md @@ -200,3 +200,43 @@ - 修复或规避:新增只读 `knowledge_graph_observation()` 数据合同和观察窗;复用 GET `/graph`,返回统计、节点、关系和 `readonly=true`,前端只渲染 SVG、统计卡片和详情查看,不增加删除、编辑、合并或写入按钮。 - 预防规则:所有可视化观察功能默认只读;任何修改能力必须单独设计 POST 合同、二次确认、审计和回滚,不能从观察图直接派生。 - 验证证据:面板回归 `9` 项通过;Node `--check`、Python `py_compile` 通过;临时 SQLite 验证返回 2 个节点、1 条关系和 `readonly=True`。 + +## 2026-07-26 — M6.1.3-A Bot 归档可靠写入合同 + +- 阶段:M6.1.3-A 记忆侧归档合同、可靠幂等写入和五类 Bridge +- 类型:API契约 / 数据隔离 / 测试 +- 现象:旧 Bot Personal 写入把 payload 拼入 record_id、所有类型统一映射为 bot_action,通用 SQLite UPSERT 可静默覆盖乱序版本,递归隐私清洗也会静默丢弃字段。 +- 根因:此前只有逻辑域和类型骨架,没有独立的 envelope 校验、版本竞争和 Bot 专用原子写入路径。 +- 修复或规避:冻结 capability/payload schema 1.0;record_id 只由域、类型和幂等键生成;新增同键去重、新版本更新、旧版本拒绝和同版本冲突;五类类型固化真实性;递归拒绝敏感字段、完整聊天、凭据、Base64、媒体二进制和本机路径;写入强制 bot_self_schedule 与 bot_self。 +- 预防规则:任何 Bridge 能力只有在返回合同、错误码、版本竞争和隐私拒绝均有测试后才可声明 FROZEN;计划不得复用 observed/bot_action 默认值。 +- 验证证据:M6.1.3-A 定向 9 项通过;OPS 纯测试 143 项通过;compileall 通过;git diff --check 通过;共享合同已更新为 FROZEN。 + +## 2026-07-26 — Envelope 校验不能只检查非空和 body payload + +- 阶段:M6.1.3 联合审查 +- 类型:API契约 / 数据完整性 / 测试 +- 现象:非法日期、窗口和时间可落库;同版本只改变 source_refs/window/certainty 会被去重;20KB 字符串被静默截断后接受。 +- 根因:时间字段只做非空校验,fingerprint 未覆盖完整 Envelope,字符串在大小检查前被截断。 +- 修复或规避:R1 增加严格格式和枚举校验、canonical Envelope fingerprint、原始大小检查和超限拒绝。 +- 预防规则:幂等比较必须覆盖所有持久化语义字段;任何合同声明“拒绝”的数据都不得通过预处理静默变形后落库。 +- 验证证据:联合审查最小复现已分别得到 `ok=true`、`deduplicated=true` 和落库 4000 字符结果。 + +## 2026-07-26 — M6.1.3-R1 联合审查阻断修复 + +- 阶段:R1 记忆侧严格字段、canonical fingerprint、超限拒绝和兼容回归 +- 类型:API契约 / 数据隔离 / 测试 +- 现象:联合审查复现出非法日期、非法窗口、无时区时间可写入;20KB 字符串被静默截断;fingerprint 未覆盖 Envelope;plan 允许非 L0;旧 creative/media/subjective/shared 类型会落入 observed;部分运行错误码未声明。 +- 根因:第一版只完成 Bot 域和幂等骨架,没有把 FROZEN Envelope 的所有语义字段统一送入验证与 canonical fingerprint,非五类类型也使用了过宽默认合同。 +- 修复或规避:增加严格日期/窗口/时区解析;原始 JSON payload 先验大小再清洗;fingerprint 覆盖 payload、日期、窗口、发生时间、来源、确定性、证据等级、状态、版本、幂等键、schema 和 source_kind;plan 强制 L0;非五类恢复显式真实性和兼容 wrapper;错误码与 capability/共享合同同步。 +- 预防规则:FROZEN 合同的每个落库语义字段都必须有单独变化冲突测试;任何清洗前截断都视为数据完整性风险;旧能力不能用 observed 兜底。 +- 验证证据:R1 定向 15 项通过;OPS 纯测试 143 项通过;compileall 和 git diff --check 通过;共享合同字段规范仍为 FROZEN 1.0,实施验收保持 REOPEN_REQUIRED。 + +## 2026-07-26 — M6.1.3-R2 非五类回归与值级隐私加固 + +- 阶段:R2 记忆侧真实调用方形状回归 + 值级隐私加固(本侧不放松任何校验) +- 类型:API契约 / 隐私 / 测试 +- 现象:R1 说「旧 creative/media/subjective/shared 类型不再落入 observed」,本仓测试也确实全绿——但真实链路上五个旧 kind 全被 `invalid_date` 拒绝。根因在陪伴侧 DTO 不派生 date,而本侧测不出来,是因为 `envelope_payload()` 夹具恒在 payload 里塞满 date/window/occurred_at,形状与调用方真实输出(信封字段走 kwarg、body 里没有 date)根本不同。另外 `_FORBIDDEN_VALUE_PATTERNS` 的路径模式 `^` 锚定,只防「整条就是路径」,句子中间的 `D:\...`、`/home/...`、`base64,`、`data:` URI 全部漏过——而合同第 130 行明写禁止这些,属合同缺口而非可选加固。 +- 根因:提供方按自己的 API 签名造夹具,没拿调用方实际输出当样本;敏感模式按「字段值 = 敏感值」设计,没按「敏感值嵌在自然语言里」设计。两处都因对端恰好有补偿(陪伴侧先拦、合同强制覆盖 source_kind)而长期看不出来。 +- 修复或规避:新增 `tests/test_m6_r2_real_dto_shape.py`——优先 import 陪伴仓真实的 `build_bot_personal_dto` 产出信封,拿不到时退回逐字复刻样本,两条路径 body 里都没有 date;补齐 R1 漏测的 `bot_calendar_event`,并用集合断言把覆盖范围钉在 `BOT_PERSONAL_TYPE_CONTRACTS` 减严格五类上。`_FORBIDDEN_VALUE_PATTERNS` 由 4 条增至 8 条(保留原前缀模式,新增中缀路径 / `base64,` / `data:` URI / `-----begin `)。date 校验一字未改,`date=""`、`2026-13-45`、naive `occurred_at` 三条负例钉死。 +- 预防规则:跨插件兼容回归必须包含调用方真实序列化输出样本,禁止只用提供方自造夹具;值级敏感检测一律按中缀设计并配反例防误杀;「覆盖了哪几类」要用集合断言钉住,不能靠人肉核对。 +- 验证证据:新增 45 项通过;记忆侧总计 243 项通过;`compileall` 通过;无新增错误码(全部复用 `privacy_rejected`,capability 25 码不变);联合 E2E 90 项全通过、非五类 7/7;实施验收由 `REOPEN_REQUIRED` 转 `LOCAL_ACCEPTED`。 diff --git a/page_api.py b/page_api.py index 2250640..78d1a22 100644 --- a/page_api.py +++ b/page_api.py @@ -18,11 +18,13 @@ from zoneinfo import ZoneInfo from quart import jsonify, request, send_file try: + from .core.bot_profiles import describe_bot_profiles from .core.bridge import serialize_memory from .core.identity import normalize_session_context_fields from .core.models import SessionContext, clean_text from .core.user_memory_boundary import USER_MEMORY_DOMAIN except ImportError: + from core.bot_profiles import describe_bot_profiles from core.bridge import serialize_memory from core.identity import normalize_session_context_fields from core.models import SessionContext, clean_text @@ -120,6 +122,10 @@ class PluginPageApi: ("/import/livingmemory/run", self.import_run, ["POST"], "MemoryCompanion Page import run"), ("/persona-state", self.persona_state, ["GET"], "MemoryCompanion Page persona state"), ("/acl/matrix", self.acl_matrix, ["GET"], "MemoryCompanion Page ACL matrix"), + # M6.1.6:Bot 长期归档只读视图。只读、只出 Bot 域,写入仍走受控归档路径。 + ("/bot-archive/profiles", self.bot_archive_profiles, ["GET"], "MemoryCompanion Bot archive profile contracts (M6.1.6)"), + ("/bot-archive/query", self.bot_archive_query, ["GET"], "MemoryCompanion Bot archive read-only query (M6.1.6)"), + ("/bot-archive/locked-frame", self.bot_archive_locked_frame, ["GET"], "MemoryCompanion Locked Frame personal DTO (M6.1.6)"), ] for prefix in PAGE_API_PREFIXES: for route, handler, methods, desc in routes: @@ -421,6 +427,49 @@ class PluginPageApi: bucket.pop("pending_count", None) return self._ok({"buckets": buckets}) + # ---- M6.1.6 Bot 长期归档只读视图 ---- + # 页面只调这三个端点读 Bot 归档,不碰 /memories 那套通用入口——通用入口按域/类型自由过滤, + # 既拿不到 Profile 的时间窗与字段白名单,也没法保证「用户域绝不混入」。 + + async def bot_archive_profiles(self): + """公布 Profile 契约,页面据此渲染分区,不必自己猜类型和条数。""" + return self._ok({ + "data_source": "memory_archive", + "source_plugin": "memory_companion", + "read_only": True, + "profiles": describe_bot_profiles(), + }) + + async def bot_archive_query(self): + profile = clean_text(request.args.get("profile", ""), 80) + query = clean_text(request.args.get("q", ""), 200) + limit = self._query_int("limit", 0) + result = await self.plugin.service.search_bot_personal_profile( + profile, query, limit=limit or None) + return self._ok({ + "data_source": "memory_archive", + "source_plugin": "memory_companion", + **result, + }) + + async def bot_archive_locked_frame(self): + """Locked Frame 人格连续性 DTO:近期全类型少量取样,按类型分组便于页面直接渲染。""" + result = await self.plugin.service.search_bot_personal_profile( + "locked_frame_personal", clean_text(request.args.get("q", ""), 200)) + grouped: dict[str, list[dict[str, Any]]] = {} + for item in result.get("memories", []): + grouped.setdefault(str(item.get("memory_type") or "unknown"), []).append(item) + return self._ok({ + "data_source": "memory_archive", + "source_plugin": "memory_companion", + "read_only": True, + "profile": result.get("profile"), + "memory_domain": result.get("memory_domain"), + "groups": grouped, + "total": len(result.get("memories", [])), + "warnings": result.get("warnings", []), + }) + async def memories(self): limit = self._query_int("limit", 50) query = clean_text(request.args.get("q", ""), 200) @@ -456,17 +505,36 @@ class PluginPageApi: payload["content_fingerprint"] = record.content_fingerprint return self._ok({"memory": payload}) - async def memory_update(self): - payload = await self._json() - memory_id = clean_text(payload.get("id"), 120) + async def _reject_if_bot_domain(self, memory_id: str, action: str): + """M6.1.7-3:Bot 域记录不接受通用写入,只能走受控归档路径。 + + 受控路径带幂等键、版本、指纹和隐私校验;从这里带外改一条 Bot 记录, + 不仅绕过全部校验,还会让它的 payload_fingerprint 变陈——下一次正常归档 + 同一个幂等键就会撞 version_conflict(永久错)直接进死信,归档链路从此静默失效。 + + 返回错误响应表示应当拒绝;返回 None 表示放行。 + """ + if not memory_id: + return self._err("missing id", 400) record = await self.plugin.service.store.get_memory(memory_id) if not record: return self._err("memory not found", 404) + domain = clean_text(getattr(record, "memory_domain", ""), 60) + if domain and domain != USER_MEMORY_DOMAIN: + logger.warning("[MemoryCompanionPage] 拒绝对非用户域记录的通用%s: id=%s domain=%s", action, memory_id, domain) + return self._err(f"non_user_memory_{action}_locked", 409) + return None + + async def memory_update(self): + payload = await self._json() + memory_id = clean_text(payload.get("id"), 120) + rejection = await self._reject_if_bot_domain(memory_id, "update") + if rejection is not None: + return rejection + record = await self.plugin.service.store.get_memory(memory_id) requested_visibility = clean_text(payload.get("visibility"), 40) if getattr(record, "memory_domain", "") != USER_MEMORY_DOMAIN and requested_visibility not in {"", "internal"}: return self._err("non_user_memory_visibility_locked", 409) - if not memory_id: - return self._err("missing id", 400) ok = await self.plugin.service.store.update_memory_payload( memory_id, memory_type=payload.get("memory_type"), @@ -483,12 +551,18 @@ class PluginPageApi: async def memory_delete(self): payload = await self._json() - ok = await self.plugin.service.store.delete_memory(clean_text(payload.get("id"), 120)) + memory_id = clean_text(payload.get("id"), 120) + rejection = await self._reject_if_bot_domain(memory_id, "delete") + if rejection is not None: + return rejection + ok = await self.plugin.service.store.delete_memory(memory_id) return self._ok({"deleted": ok}) async def memory_visibility(self): payload = await self._json() memory_id = clean_text(payload.get("id"), 120) + if not memory_id: + return self._err("missing id", 400) record = await self.plugin.service.store.get_memory(memory_id) if not record: return self._err("memory not found", 404) @@ -503,8 +577,12 @@ class PluginPageApi: async def memory_lifecycle(self): payload = await self._json() + memory_id = clean_text(payload.get("id"), 120) + rejection = await self._reject_if_bot_domain(memory_id, "lifecycle") + if rejection is not None: + return rejection ok = await self.plugin.service.store.update_memory_lifecycle( - clean_text(payload.get("id"), 120), + memory_id, clean_text(payload.get("lifecycle"), 40), ) return self._ok({"updated": ok}) diff --git a/tests/test_audit_batch1_fixes.py b/tests/test_audit_batch1_fixes.py new file mode 100644 index 0000000..ea071c1 --- /dev/null +++ b/tests/test_audit_batch1_fixes.py @@ -0,0 +1,340 @@ +"""OPS 源码审计 Batch 1(记忆侧)定向回归。 + +覆盖 B12(未转义 LIKE)、B21(域判定常量单一来源)、B23(恢复成功计数)、 +B13(记忆侧时区统一为带时区)。 +""" + +from __future__ import annotations + +import ast +import sqlite3 +import sys +import tempfile +import unittest +from datetime import datetime, timezone +from pathlib import Path +from zoneinfo import ZoneInfo + + +ROOT = Path(__file__).resolve().parents[1] +if str(ROOT.parent) not in sys.path: + sys.path.insert(0, str(ROOT.parent)) + +from core import models, service as service_module, user_memory_boundary as boundary +from core.models import EntityRef, MemoryRecord +from core.store import MemoryStore +from core.temporal_context import local_now +from core.user_memory_boundary import UserMemoryBoundaryError, infer_memory_domain, validate_user_memory_record + + +def make_store(test: unittest.TestCase) -> MemoryStore: + temp_dir = tempfile.TemporaryDirectory() + test.addCleanup(temp_dir.cleanup) + store = MemoryStore(Path(temp_dir.name) / "memory.db") + store.initialize() + test.addCleanup(store.close) + return store + + +def user_memory(memory_id: str, *, user_id: str, session_id: str, content: str) -> MemoryRecord: + return MemoryRecord( + id=memory_id, + memory_type="user_fact", + memory_domain="user_memory", + subject=EntityRef(kind="user", id=user_id, name=user_id), + object=EntityRef.bot_self(), + scope="private", + session_id=session_id, + platform="qq", + message_id=f"msg-{memory_id}", + visibility="private_pair", + lifecycle="stable_memory", + content=content, + evidence=content, + ) + + +class EntityLikeEscapeTests(unittest.IsolatedAsyncioTestCase): + """B12 · core/store.py 的 entity_id 过滤必须转义 LIKE 通配符。""" + + async def test_underscore_in_entity_id_does_not_match_other_sessions(self) -> None: + store = make_store(self) + await store.insert_memory( + user_memory("mem_underscore", user_id="u_1", session_id="qq:FriendMessage:u_1", content="下划线用户的记忆。") + ) + await store.insert_memory( + user_memory("mem_neighbor", user_id="uX1", session_id="qq:FriendMessage:uX1", content="另一个会话的记忆。") + ) + + rows = await store.list_memories(entity_id="u_1", limit=50) + + self.assertEqual({"mem_underscore"}, {row.id for row in rows}) + + async def test_percent_in_entity_id_does_not_match_other_sessions(self) -> None: + store = make_store(self) + await store.insert_memory( + user_memory("mem_percent", user_id="a%b", session_id="qq:FriendMessage:a%b", content="百分号用户的记忆。") + ) + await store.insert_memory( + user_memory("mem_wildcard", user_id="aQQb", session_id="qq:FriendMessage:aQQb", content="不应被通配命中的记忆。") + ) + + rows = await store.list_memories(entity_id="a%b", limit=50) + + self.assertEqual({"mem_percent"}, {row.id for row in rows}) + + async def test_exact_entity_id_still_matches_by_session_suffix(self) -> None: + store = make_store(self) + await store.insert_memory( + user_memory("mem_plain", user_id="995051631", session_id="qq:FriendMessage:995051631", content="普通用户的记忆。") + ) + + rows = await store.list_memories(entity_id="995051631", limit=50) + + self.assertEqual({"mem_plain"}, {row.id for row in rows}) + + +class DatabaseRecoveryCounterTests(unittest.TestCase): + """B23 · 恢复成功计数只能在重试真正成功后自增。""" + + @staticmethod + def path_error() -> sqlite3.OperationalError: + return sqlite3.OperationalError("unable to open database file") + + def test_second_failure_is_not_counted_as_recovery_success(self) -> None: + store = make_store(self) + calls: list[int] = [] + + def always_fail(*_args: object) -> object: + calls.append(1) + raise self.path_error() + + with self.assertRaises(sqlite3.OperationalError): + store._run_with_database_recovery_sync(always_fail) + + self.assertEqual(2, len(calls), "首次执行 + 恢复后重试各一次") + self.assertEqual(1, store._database_recovery_attempts) + self.assertEqual(0, store._database_recovery_successes) + + def test_successful_retry_counts_once(self) -> None: + store = make_store(self) + state = {"calls": 0} + + def fail_once(*_args: object) -> str: + state["calls"] += 1 + if state["calls"] == 1: + raise self.path_error() + return "ok" + + self.assertEqual("ok", store._run_with_database_recovery_sync(fail_once)) + self.assertEqual(1, store._database_recovery_attempts) + self.assertEqual(1, store._database_recovery_successes) + + def test_non_path_error_is_reraised_without_touching_counters(self) -> None: + store = make_store(self) + + def other_failure(*_args: object) -> object: + raise sqlite3.OperationalError("no such table: memories") + + with self.assertRaises(sqlite3.OperationalError): + store._run_with_database_recovery_sync(other_failure) + + self.assertEqual(0, store._database_recovery_attempts) + self.assertEqual(0, store._database_recovery_successes) + + +class MemoryDomainConstantSourceTests(unittest.TestCase): + """B21 · 域判定集合只有一份来源,且用户记忆写入门禁不放松。""" + + def test_boundary_reexports_the_same_frozensets_as_models(self) -> None: + self.assertIs(models.BOT_SELF_MEMORY_TYPES, boundary.BOT_SELF_MEMORY_TYPES) + self.assertIs(models.BOT_SELF_REALITY_LEVELS, boundary.BOT_SELF_REALITY_LEVELS) + self.assertIs(models.USER_MEMORY_TYPES, boundary.USER_MEMORY_TYPES) + self.assertIs(models.USER_MEMORY_WRITE_BLOCKED_TYPES, boundary.USER_MEMORY_WRITE_BLOCKED_TYPES) + + def test_models_no_longer_inlines_domain_type_literals(self) -> None: + source = (ROOT / "core" / "models.py").read_text(encoding="utf-8-sig") + tree = ast.parse(source) + ensure_defaults = next( + node + for node in ast.walk(tree) + if isinstance(node, ast.FunctionDef) and node.name == "ensure_defaults" + ) + inlined = [ + element.value + for node in ast.walk(ensure_defaults) + if isinstance(node, ast.Set) + for element in node.elts + if isinstance(element, ast.Constant) + ] + self.assertEqual([], inlined, "ensure_defaults 不得再内联域判定类型清单") + + def test_ensure_defaults_and_infer_agree_on_bot_self_types(self) -> None: + for memory_type in sorted(models.BOT_SELF_MEMORY_TYPES): + with self.subTest(memory_type=memory_type): + record = MemoryRecord( + memory_type=memory_type, + memory_domain="", + subject=EntityRef(kind="user", id="u1"), + ) + record.ensure_defaults() + # calendar_event 由更前置的日历分支接管(B10 另行确认意图)。 + expected = "calendar_history" if memory_type == "calendar_event" else "bot_self_legacy" + self.assertEqual(expected, record.memory_domain) + + probe = MemoryRecord( + memory_type=memory_type, + memory_domain="", + subject=EntityRef(kind="user", id="u1"), + ) + self.assertEqual("bot_self_legacy", infer_memory_domain(probe)) + + def test_decay_summary_domain_follows_source_records_not_bot_self(self) -> None: + record = MemoryRecord( + memory_type="memory_decay_summary", + memory_domain="", + subject=EntityRef(kind="user", id="u1"), + reality_level="llm_summary", + ) + record.ensure_defaults() + self.assertEqual("user_memory", record.memory_domain) + self.assertEqual( + record.memory_domain, + infer_memory_domain( + MemoryRecord( + memory_type="memory_decay_summary", + memory_domain="", + subject=EntityRef(kind="user", id="u1"), + reality_level="llm_summary", + ) + ), + "两个分类器对衰减总结必须给出同一个域", + ) + + def test_decay_summary_is_still_rejected_by_the_user_memory_write_gate(self) -> None: + record = MemoryRecord( + memory_type="memory_decay_summary", + memory_domain="user_memory", + subject=EntityRef(kind="user", id="u1"), + object=EntityRef.bot_self(), + scope="private", + session_id="qq:FriendMessage:u1", + message_id="msg-1", + visibility="private_pair", + reality_level="llm_summary", + content="衰减总结正文。", + evidence="来源片段。", + ) + + with self.assertRaises(UserMemoryBoundaryError) as caught: + validate_user_memory_record(record) + + self.assertEqual("bot_self_memory_type:memory_decay_summary", caught.exception.reason) + + def test_memory_domain_default_is_not_empty_so_classification_needs_explicit_reset(self) -> None: + # 记录既有陷阱:memory_domain 默认 "unknown" 为真值, + # ensure_defaults 的分类分支只在调用方显式传 "" 时才会执行。 + self.assertEqual("unknown", MemoryRecord().memory_domain) + untouched = MemoryRecord(memory_type="user_fact", subject=EntityRef(kind="user", id="u1")) + untouched.ensure_defaults() + self.assertEqual("unknown", untouched.memory_domain) + + +class MemorySideTimezoneTests(unittest.TestCase): + """B13 · 记忆侧时钟必须带时区,容器 TZ 不能改变分桶与时段判定。""" + + def test_local_now_is_timezone_aware_and_uses_configured_zone(self) -> None: + now = local_now() + self.assertIsNotNone(now.tzinfo) + expected = datetime.now(timezone.utc).astimezone(ZoneInfo("Asia/Shanghai")) + self.assertEqual(expected.utcoffset(), now.utcoffset()) + self.assertEqual(expected.date(), now.date()) + self.assertEqual(expected.hour, now.hour) + + def test_local_now_falls_back_when_timezone_name_is_invalid(self) -> None: + now = local_now(timezone_name="Not/AZone") + self.assertIsNotNone(now.tzinfo) + self.assertEqual(datetime.now(ZoneInfo("Asia/Shanghai")).utcoffset(), now.utcoffset()) + + def test_no_naive_datetime_now_call_remains_in_memory_plugin(self) -> None: + targets = sorted((ROOT / "core").glob("*.py")) + [ROOT / "page_api.py", ROOT / "main.py"] + offenders: list[str] = [] + for path in targets: + tree = ast.parse(path.read_text(encoding="utf-8-sig")) + for node in ast.walk(tree): + if ( + isinstance(node, ast.Call) + and isinstance(node.func, ast.Attribute) + and node.func.attr == "now" + and isinstance(node.func.value, ast.Name) + and node.func.value.id == "datetime" + and not node.args + and not node.keywords + ): + offenders.append(f"{path.name}:{node.lineno}") + self.assertEqual([], offenders, "记忆侧不得使用 naive datetime.now()") + + def test_time_of_day_and_rest_check_read_the_local_clock(self) -> None: + fixed = datetime(2026, 7, 26, 1, 30, tzinfo=ZoneInfo("Asia/Shanghai")) + original = service_module.local_now + service_module.local_now = lambda *args, **kwargs: fixed + try: + self.assertEqual( + "late_night", + service_module.MemoryCompanionService._compute_time_of_day(object()), + ) + self.assertTrue(service_module.MemoryCompanionService._message_is_short_rest_check("查岗")) + finally: + service_module.local_now = original + + def test_token_buckets_use_local_day_and_hour_keys(self) -> None: + fixed = datetime(2026, 7, 26, 1, 30, tzinfo=ZoneInfo("Asia/Shanghai")) + original = service_module.local_now + service_module.local_now = lambda *args, **kwargs: fixed + try: + recorder = _TokenUsageRecorder() + service_module.MemoryCompanionService._record_token_usage( + recorder, + task="unit_test", + provider_id="p1", + prompt="hello", + completion="world", + ) + finally: + service_module.local_now = original + + self.assertIn("2026-07-26", recorder._token_usage["by_day"]) + self.assertIn("2026-07-26T01:00", recorder._token_usage["by_hour"]) + + +class _TokenUsageRecorder: + """只提供 `_record_token_usage` 需要的最小依赖,避免拉起整个服务。""" + + def __init__(self) -> None: + self._token_usage: dict[str, object] = {} + self.saved = 0 + + def _save_token_usage(self) -> None: + self.saved += 1 + + def _extract_token_usage(self, *_args: object, **_kwargs: object) -> dict[str, object]: + return { + "prompt_tokens": 1, + "completion_tokens": 1, + "total_tokens": 2, + "cached_tokens": 0, + "cache_read_tokens": 0, + "cache_write_tokens": 0, + "estimated": True, + } + + @staticmethod + def _safe_int(value: object) -> int: + try: + return int(value or 0) + except (TypeError, ValueError): + return 0 + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_bot_personal_memory.py b/tests/test_bot_personal_memory.py index 182d66e..a93de98 100644 --- a/tests/test_bot_personal_memory.py +++ b/tests/test_bot_personal_memory.py @@ -1,103 +1,283 @@ import asyncio import tempfile from pathlib import Path +from types import SimpleNamespace from core.bridge import MemoryCompanionBridge from core.models import EntityRef, MemoryRecord +from core.retrieval import RetrievalEngine from core.service import MemoryCompanionService from core.store import MemoryStore from core.visibility import VisibilityPolicy -from core.retrieval import RetrievalEngine + + +class Config: + def __init__(self, enabled=True): + self.enabled = enabled + + def bool(self, key, default=True): + return self.enabled + + +def make_service(temp_dir, enabled=True): + service = object.__new__(MemoryCompanionService) + service.config = Config(enabled) + service.store = MemoryStore(Path(temp_dir) / "memory.db") + service.store.initialize() + service._schedule_memory_embedding = lambda *args, **kwargs: None + return service + + +def envelope_payload(index=1, **extra): + payload = { + "date": "2026-07-26", + "window": "afternoon", + "occurred_at": "2026-07-26T15:00:00+08:00", + "source_refs": [f"companion:event:{index}"], + "certainty": 0.9, + "evidence_level": "L2", + "version": 1, + "idempotency_key": f"m6.1.3:{index}", + "payload_schema_version": "1.0", + "summary": "完成一次真实活动摘要", + } + payload.update(extra) + return payload + + +def write(service, memory_type, payload, **kwargs): + return asyncio.run(service.record_bot_personal_memory(memory_type=memory_type, payload=payload, **kwargs)) def test_bot_personal_capability_contract(): service = object.__new__(MemoryCompanionService) + service.config = Config() payload = service.bridge_probe_bot_personal_memory_capabilities() assert payload["available"] is True assert payload["memory_domain"] == "bot_self_schedule" - assert payload["four_window_schedule"] is True - assert payload["user_memory_isolation"] is True + assert payload["capability_schema_version"] == "1.0" + assert payload["payload_schema_version"] == "1.0" + assert set(payload["dedicated_methods"]) == { + "record_bot_schedule_plan", + "record_bot_observed_activity", + "record_bot_schedule_reconciliation", + "record_bot_window_snapshot", + "record_bot_daily_diary", + } -def test_bot_personal_write_forces_domain_and_stable_idempotency(): - service = object.__new__(MemoryCompanionService) - calls = [] - - async def fake_record_external_event(**kwargs): - calls.append(kwargs) - return kwargs["memory_id"] - - service.record_external_event = fake_record_external_event - first = asyncio.run(service.record_bot_personal_memory( - memory_type="bot_window_snapshot", - payload={"date": "2026-07-25", "window": "morning", "source_refs": ["snapshot:1"]}, - occurred_at="2026-07-25T12:00:00+08:00", - idempotency_key="window_snapshot:2026-07-25:morning", - )) - second = asyncio.run(service.record_bot_personal_memory( - memory_type="bot_window_snapshot", - payload={"date": "2026-07-25", "window": "morning", "source_refs": ["snapshot:1"]}, - occurred_at="2026-07-25T12:00:00+08:00", - idempotency_key="window_snapshot:2026-07-25:morning", - )) - assert first == second - assert calls[0]["memory_domain"] == "bot_self_schedule" - assert calls[0]["visibility"] == "bot_self" - assert calls[0]["session_id"] == "bot_personal" - - -def test_bot_personal_search_excludes_user_memory(): +def test_five_types_have_truth_mapping_and_unified_return(): with tempfile.TemporaryDirectory() as temp: - store = MemoryStore(Path(temp) / "memory.db") - store.initialize() - store_records = [ - MemoryRecord( - id="bot-1", - memory_type="bot_daily_diary", - memory_domain="bot_self_schedule", - subject=EntityRef.bot_self(), - scope="private", - session_id="bot_personal", - visibility="bot_self", - reality_level="persona_life", - content="Bot 今天完成了创作。", - occurred_at="2026-07-25T21:00:00+08:00", - ), - MemoryRecord( - id="user-1", - memory_type="user_fact", - memory_domain="user_memory", - subject=EntityRef(kind="user", id="u1"), - scope="private", - session_id="private:u1", - visibility="private_pair", - reality_level="real_user_fact", - content="用户也喜欢创作。", - ), + service = make_service(temp) + cases = [ + ("bot_schedule_plan", "planned", "planned", "planned"), + ("bot_observed_activity", "observed", "observed_activity", "observed"), + ("bot_schedule_reconciliation", "reconciled", "reconciled", "reconciled"), + ("bot_window_snapshot", "projection", "window_projection", "projection"), + ("bot_daily_diary", "subjective", "subjective", "subjective"), ] - for record in store_records: - asyncio.run(store.insert_memory(record)) - service = object.__new__(MemoryCompanionService) - service.store = store - results = asyncio.run(service.search_bot_personal_memory("创作", limit=10)) - assert [item["id"] for item in results] == ["bot-1"] - store.close() + for index, (memory_type, source_kind, reality_level, expected_kind) in enumerate(cases, 1): + payload = envelope_payload(index) + if memory_type == "bot_schedule_plan": + payload["evidence_level"] = "L0" + payload["idempotency_key"] = f"truth:{index}" + result = write(service, memory_type, payload) + assert result["ok"] is True + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.memory_domain == "bot_self_schedule" + assert record.subject.kind == "bot" + assert record.metadata["source_kind"] == source_kind == expected_kind + assert record.reality_level == reality_level + if memory_type == "bot_schedule_plan": + assert record.reality_level != "observed_activity" + assert record.reality_level != "bot_action" + service.store.close() -def test_default_retrieval_blocks_bot_personal_domain(): - engine = RetrievalEngine(MemoryStore(Path(tempfile.gettempdir()) / "unused-m6.db"), VisibilityPolicy()) - assert engine._memory_domain_block_reason(MemoryRecord(memory_domain="bot_self_schedule")) == "missing_user_subject" +def test_stable_id_and_idempotent_same_payload(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + payload = envelope_payload(1) + first = write(service, "bot_window_snapshot", payload) + second = write(service, "bot_window_snapshot", payload) + assert first["record_id"] == second["record_id"] + assert second["deduplicated"] is True + assert second["action"] == "deduplicated" + assert first["version"] == second["version"] == 1 + service.store.close() -def test_bridge_missing_bot_personal_write_degrades_explicitly(): - bridge = MemoryCompanionBridge(object()) - try: - asyncio.run(bridge.record_bot_personal_memory( - memory_type="bot_daily_diary", - payload={"date": "2026-07-25"}, - idempotency_key="diary:2026-07-25", - )) - except RuntimeError as exc: - assert str(exc) == "bot_personal_memory_unavailable" - else: - raise AssertionError("missing Bot personal Bridge must fail explicitly") +def test_newer_version_updates_same_id_and_stale_version_is_rejected(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + payload = envelope_payload(2) + payload["evidence_level"] = "L0" + first = write(service, "bot_schedule_plan", payload) + newer = dict(payload, version=2, summary="修订后的计划") + updated = write(service, "bot_schedule_plan", newer) + stale = write(service, "bot_schedule_plan", dict(payload, version=1, summary="旧计划")) + assert updated["ok"] is True + assert updated["record_id"] == first["record_id"] + assert updated["version"] == 2 + assert stale["ok"] is False + assert stale["error_code"] == "stale_version" + record = asyncio.run(service.store.get_memory(first["record_id"])) + assert record.metadata["version"] == 2 + assert record.created_at + assert record.updated_at + service.store.close() + + +def test_same_version_different_payload_is_conflict(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + write(service, "bot_observed_activity", envelope_payload(3)) + conflict = write(service, "bot_observed_activity", envelope_payload(3, summary="不同摘要")) + assert conflict["ok"] is False + assert conflict["error_code"] == "version_conflict" + service.store.close() + + +def test_recursive_privacy_rejection_is_explicit(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + result = write(service, "bot_daily_diary", envelope_payload(4, details={"nested": [{"token": "secret-value"}]})) + assert result["ok"] is False + assert result["error_code"] == "privacy_rejected" + assert "details" in result["field"] + result = write(service, "bot_daily_diary", envelope_payload(5, media={"path": "C:\\private\\photo.png"})) + assert result["error_code"] == "privacy_rejected" + service.store.close() + + +def test_domain_isolation_and_user_query_block(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + bot_result = write(service, "bot_daily_diary", envelope_payload(6)) + user_record = MemoryRecord( + id="user-1", + memory_type="user_fact", + memory_domain="user_memory", + subject=EntityRef(kind="user", id="u1"), + scope="private", + session_id="private:u1", + visibility="private_pair", + reality_level="real_user_fact", + content="用户也在活动。", + ) + asyncio.run(service.store.insert_memory(user_record)) + bot_results = asyncio.run(service.search_bot_personal_memory("活动", limit=10)) + assert [item["id"] for item in bot_results] == [bot_result["record_id"]] + engine = RetrievalEngine(service.store, VisibilityPolicy()) + assert engine._memory_domain_block_reason(MemoryRecord(memory_domain="bot_self_schedule")) == "missing_user_subject" + service.store.close() + + +def test_bridge_has_five_methods_and_missing_bridge_returns_error_object(): + class Plugin: + async def record_bot_personal_memory(self, **kwargs): + return {"ok": True, "record_id": "x", "deduplicated": False, "version": 1, "error_code": None} + + bridge = MemoryCompanionBridge(Plugin()) + payload = envelope_payload(7) + for method_name in ( + "record_bot_schedule_plan", + "record_bot_observed_activity", + "record_bot_schedule_reconciliation", + "record_bot_window_snapshot", + "record_bot_daily_diary", + ): + result = asyncio.run(getattr(bridge, method_name)(payload=payload)) + assert result["ok"] is True + missing = MemoryCompanionBridge(object()) + result = asyncio.run(missing.record_bot_daily_diary(payload=payload)) + assert result["ok"] is False + assert result["error_code"] == "bridge_method_unavailable" + + +def test_invalid_date_window_and_timezone_are_rejected(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + assert write(service, "bot_daily_diary", dict(envelope_payload(20), date="not-a-date"))["error_code"] == "invalid_date" + assert write(service, "bot_daily_diary", dict(envelope_payload(21), window="not_a_window"))["error_code"] == "invalid_window" + assert write(service, "bot_daily_diary", dict(envelope_payload(22), occurred_at="2026-07-26T15:00:00"))["error_code"] == "invalid_occurred_at" + service.store.close() + + +def test_raw_payload_over_16k_is_rejected_without_storage(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + payload = envelope_payload(23, summary="x" * 20000) + result = write(service, "bot_daily_diary", payload) + assert result["ok"] is False + assert result["error_code"] == "payload_too_large" + assert asyncio.run(service.store.list_memories(limit=20, visibility="bot_self")) == [] + service.store.close() + + +def test_same_version_envelope_changes_conflict_and_fingerprint_covers_fields(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + payload = envelope_payload(24) + first = write(service, "bot_observed_activity", payload) + changed = dict(payload, window="evening", certainty=0.5, evidence_level="L1", status="completed", source_refs=["companion:event:changed"]) + result = write(service, "bot_observed_activity", changed) + assert result["ok"] is False + assert result["error_code"] == "version_conflict" + record = asyncio.run(service.store.get_memory(first["record_id"])) + assert record.metadata["window"] == "afternoon" + assert record.metadata["certainty"] == 0.9 + service.store.close() + + +def test_non_five_legacy_types_keep_explicit_truth_mapping(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + cases = { + "bot_creative_work": "creative_work", + "bot_media_memory": "media_index", + "bot_subjective_memory": "subjective", + "bot_shared_activity": "shared_activity", + "bot_detail_fragment": "detail_fragment", + "bot_proactive_message": "proactive_action", + } + for index, (memory_type, reality_level) in enumerate(cases.items(), 30): + payload = envelope_payload(index, idempotency_key=f"legacy:{index}", evidence_level="L2") + result = write(service, memory_type, payload) + assert result["ok"] is True + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.reality_level == reality_level + assert record.metadata["source_kind"] != "observed" + assert record.metadata["evidence_level"] == "L2" + service.store.close() + + +def test_dedicated_and_generic_bridge_paths_share_fingerprint(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + bridge = MemoryCompanionBridge(service) + payload = envelope_payload(40, idempotency_key="same:bridge", evidence_level="L2") + first = asyncio.run(bridge.record_bot_creative_work(payload=payload)) + second = asyncio.run(bridge.record_bot_personal_memory(memory_type="bot_creative_work", payload=payload)) + assert first["ok"] is True + assert second["ok"] is True + assert second["deduplicated"] is True + assert first["record_id"] == second["record_id"] + service.store.close() + + +def test_capability_error_codes_cover_runtime_validation_errors(): + service = object.__new__(MemoryCompanionService) + service.config = Config() + capability = service.bridge_probe_bot_personal_memory_capabilities() + declared = set(capability["error_codes"]) + assert {"invalid_date", "invalid_window", "invalid_occurred_at", "invalid_field", "payload_too_large", "version_conflict"} <= declared + + +def test_write_disabled_returns_contract_error(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp, enabled=False) + result = write(service, "bot_daily_diary", envelope_payload(8)) + assert result["ok"] is False + assert result["error_code"] == "bridge_write_disabled" + service.store.close() diff --git a/tests/test_m6_r2_real_dto_shape.py b/tests/test_m6_r2_real_dto_shape.py new file mode 100644 index 0000000..ed496b3 --- /dev/null +++ b/tests/test_m6_r2_real_dto_shape.py @@ -0,0 +1,357 @@ +"""M6.1.3-R2 真实陪伴 DTO 形状兼容回归 + 值级隐私加固回归。 + +R1 的教训写在这里:本仓所有 bot_personal 用例的夹具都恒带 date/window/occurred_at, +验证的是"喂满字段的兼容"。而调用方(陪伴插件)真实吐出的 DTO 里,非五类旧 kind 天然没有 +date,于是"兼容能力"在真实链路上全线 invalid_date,测试却全绿。 + +因此本模块坚持用**调用方的真实序列化输出**做回归:能拿到陪伴仓时直接调它的 +build_bot_personal_dto,拿不到时也用逐字复刻的真实形状样本,绝不使用提供方自造的满字段夹具。 + +本侧不放松任何校验:date 为空仍必须 invalid_date(主修在陪伴侧)。 +""" +import asyncio +import importlib.util +import json +import sys +import tempfile +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import pytest + +from core.bot_personal import BOT_PERSONAL_TYPE_CONTRACTS +from core.service import MemoryCompanionService +from core.store import MemoryStore + +TZ = timezone(timedelta(hours=8)) +NOW = datetime(2026, 7, 27, 18, 0, 0, tzinfo=TZ) +COMPANION_ROOT = Path(__file__).resolve().parents[2] / "astrbot_plugin_private_companion-main" + +# 陪伴侧 _memory_companion_archive_type 里的七个非五类 kind → memory_type → 期望 reality_level +LEGACY_KINDS = ( + ("creative_progress", "bot_creative_work", "creative_work"), + ("daily_outfit", "bot_media_memory", "media_index"), + ("dream_fragment", "bot_subjective_memory", "subjective"), + ("shared_activity", "bot_shared_activity", "shared_activity"), + ("detail_enhancement", "bot_detail_fragment", "detail_fragment"), + ("calendar_event", "bot_calendar_event", "calendar_history"), + ("proactive_message", "bot_proactive_message", "proactive_action"), +) + + +class Config: + def __init__(self, enabled=True): + self.enabled = enabled + + def bool(self, key, default=True): + return self.enabled + + +def make_service(temp_dir): + service = object.__new__(MemoryCompanionService) + service.config = Config() + service.store = MemoryStore(Path(temp_dir) / "memory.db") + service.store.initialize() + service._schedule_memory_embedding = lambda *args, **kwargs: None + return service + + +def load_companion_dto_module(): + """加载陪伴插件真实的 DTO 构造器(该模块只依赖标准库,可独立载入)。""" + module_path = COMPANION_ROOT / "bot_personal_dto.py" + if not module_path.exists(): + return None + if "companion_bot_personal_dto" in sys.modules: + return sys.modules["companion_bot_personal_dto"] + spec = importlib.util.spec_from_file_location("companion_bot_personal_dto", module_path) + module = importlib.util.module_from_spec(spec) + sys.modules["companion_bot_personal_dto"] = module + spec.loader.exec_module(module) + return module + + +def archive_like_companion(service, envelope, *, whole_envelope=False): + """复刻 _memory_companion_send_bot_archive 的非五类(通用回退)调用形状。 + + M6.1.4 起两条路径一律送 body payload(信封字段只走 kwarg)。`whole_envelope=True` + 保留旧的整包信封形状,用来验证信封字段剥离仍然生效、指纹不受时间戳漂移影响。 + """ + return asyncio.run(service.record_bot_personal_memory( + memory_type=envelope["memory_type"], + payload=envelope if whole_envelope else envelope["payload"], + occurred_at=envelope["occurred_at"], + idempotency_key=envelope["idempotency_key"], + source_refs=list(envelope["source_refs"]), + date=envelope["date"], + window=envelope["window"], + certainty=envelope["certainty"], + evidence_level=envelope["evidence_level"], + version=envelope["version"], + payload_schema_version=envelope["payload_schema_version"], + status=envelope["status"], + source_plugin="private_companion", + )) + + +def real_shape_envelope(memory_type, index, *, occurred_at="2026-07-27T18:00:00+08:00", **overrides): + """逐字复刻陪伴 DTO 的真实输出形状。 + + 要点:body 里没有 date —— 这正是 R1 夹具掩盖掉的那一点;date 由 occurred_at 派生后 + 只出现在信封层。 + """ + contract = BOT_PERSONAL_TYPE_CONTRACTS[memory_type] + envelope = { + "record_id": f"local:legacy:{index}", + "memory_domain": "bot_self_schedule", + "memory_type": memory_type, + "subject": "bot_self", + "date": occurred_at[:10], + "window": "evening", + "occurred_at": occurred_at, + "created_at": occurred_at, + "updated_at": occurred_at, + "source_kind": contract["source_kind"], + "source_refs": [f"legacy:{index}"], + "certainty": 0.6, + "evidence_level": "L1", + "status": "active", + "version": 1, + "idempotency_key": f"legacy:{memory_type}:{index}", + "payload_schema_version": "1.0", + "payload": {"summary": "旧能力真实形状样本", "namespace": "bot_self_timeline", + "source_refs": [f"legacy:{index}"]}, + } + envelope.update(overrides) + return envelope + + +# -------------------------------------------------------------------------- +# M1 · 真实陪伴 DTO 形状兼容回归 +# -------------------------------------------------------------------------- + +@pytest.mark.skipif(not (COMPANION_ROOT / "bot_personal_dto.py").exists(), + reason="陪伴插件不在同一工作区,退回 real_shape_envelope 复刻样本") +@pytest.mark.parametrize("kind,memory_type,reality_level", LEGACY_KINDS) +def test_real_companion_dto_without_date_is_accepted(kind, memory_type, reality_level): + """用陪伴插件真实的 build_bot_personal_dto 产出信封,payload 刻意不带 date。""" + dto_mod = load_companion_dto_module() + assert dto_mod is not None + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + dto = dto_mod.build_bot_personal_dto( + memory_type=memory_type, kind=kind, namespace="bot_self_timeline", + payload={"summary": "真实调用方输出", "source_refs": [f"{kind}:1"]}, + idempotency_key=f"real:{kind}", occurred_at="2026-07-27T18:00:00+08:00", now=NOW) + assert dto.date == "2026-07-27", "陪伴侧应已从 occurred_at 派生日期" + assert "date" not in dto.payload, "真实 body 里本来就没有 date,夹具不得替它补上" + result = archive_like_companion(service, dto.envelope()) + assert result["ok"] is True, result + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.reality_level == reality_level + assert record.metadata["source_kind"] != "observed" + assert record.metadata["date"] == "2026-07-27" + service.store.close() + + +@pytest.mark.parametrize("kind,memory_type,reality_level", LEGACY_KINDS) +def test_real_shape_sample_is_accepted_and_not_mislabelled(kind, memory_type, reality_level): + """不依赖陪伴仓的复刻样本:body 无 date,date 只在信封层。""" + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope(memory_type, index=kind) + result = archive_like_companion(service, envelope) + assert result["ok"] is True, result + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.reality_level == reality_level + assert record.metadata["source_kind"] == BOT_PERSONAL_TYPE_CONTRACTS[memory_type]["source_kind"] + assert record.metadata["source_kind"] != "observed" + assert record.memory_type == memory_type + service.store.close() + + +def test_calendar_event_truth_mapping_is_covered(): + """R1 的 non_five 用例漏了 bot_calendar_event,这里单独钉死。""" + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope("bot_calendar_event", index="cal", + occurred_at="2026-07-25T22:30:00+08:00", window="late_night") + result = archive_like_companion(service, envelope) + assert result["ok"] is True, result + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.reality_level == "calendar_history" + assert record.metadata["source_kind"] == "calendar" + assert record.metadata["date"] == "2026-07-25" + service.store.close() + + +def test_whole_envelope_shape_stays_backward_compatible(): + """旧的整包信封形状仍必须接受,且与 body 形状产生同一个指纹。""" + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + body_first = archive_like_companion(service, real_shape_envelope("bot_creative_work", index="compat")) + assert body_first["ok"] is True, body_first + again = archive_like_companion( + service, real_shape_envelope("bot_creative_work", index="compat"), whole_envelope=True) + assert again["ok"] is True, again + assert again["action"] == "deduplicated", "两种形状指纹不一致" + service.store.close() + + +def test_envelope_timestamps_do_not_drift_the_fingerprint(): + """created_at/updated_at 属信封字段,漂移不得让同一条记录变成 version_conflict。""" + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + first = real_shape_envelope("bot_creative_work", index="drift") + assert archive_like_companion(service, first, whole_envelope=True)["ok"] is True + later = dict(first, created_at="2026-07-27T23:59:00+08:00", updated_at="2026-07-27T23:59:00+08:00") + result = archive_like_companion(service, later, whole_envelope=True) + assert result["ok"] is True, result + assert result["action"] == "deduplicated", result + service.store.close() + + +def test_all_seven_legacy_types_are_covered_by_this_module(): + """防止以后新增合同类型时本模块悄悄漏测。""" + covered = {memory_type for _, memory_type, _ in LEGACY_KINDS} + strict = {"bot_schedule_plan", "bot_observed_activity", "bot_schedule_reconciliation", + "bot_window_snapshot", "bot_daily_diary"} + assert covered == set(BOT_PERSONAL_TYPE_CONTRACTS) - strict + + +# -------------------------------------------------------------------------- +# 合同不放松:date 仍是强校验 +# -------------------------------------------------------------------------- + +def test_empty_date_is_still_rejected(): + """主修在陪伴侧;本侧绝不放松,否则两边同时改会引入新的不一致。""" + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope("bot_creative_work", index="nodate", date="") + result = archive_like_companion(service, envelope) + assert result["ok"] is False + assert result["error_code"] == "invalid_date" + service.store.close() + + +def test_malformed_date_is_still_rejected(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope("bot_creative_work", index="baddate", date="2026-13-45") + result = archive_like_companion(service, envelope) + assert result["ok"] is False + assert result["error_code"] == "invalid_date" + service.store.close() + + +def test_naive_occurred_at_is_still_rejected(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope("bot_creative_work", index="naive", + occurred_at="2026-07-27T18:00:00") + result = archive_like_companion(service, envelope) + assert result["ok"] is False + assert result["error_code"] == "invalid_occurred_at" + service.store.close() + + +# -------------------------------------------------------------------------- +# M2 · 值级隐私加固(正例:必须拒;反例:不得误杀) +# -------------------------------------------------------------------------- + +FORBIDDEN_VALUES = [ + ("data_uri_png", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUg=="), + ("data_uri_plain", "data:text/plain;charset=utf-8,hello"), + ("base64_infix", "封面图:base64,iVBORw0KGgoAAAANSUhEUg=="), + ("windows_path_infix", "照片保存在 D:\\private\\photos\\a.png 了"), + ("unc_path_infix", "备份放在 \\\\nas\\share\\bak 里"), + ("home_path_infix", "日志在 /home/bot/logs/run.log"), + ("tmp_path_infix", "临时文件写到 /tmp/session.json"), + ("var_path_infix", "落在 /var/log/astrbot.log"), + ("volume_path_infix", "NAS 上是 /volume1/media/a.png"), + ("path_after_equals", "path=/root/.ssh/id_rsa"), + ("private_key", "-----BEGIN RSA PRIVATE KEY----- MIIEowIBAAK"), + ("windows_path_prefix", "C:\\Users\\bot\\secret.txt"), + ("credential_pair", "password=hunter2"), + ("bearer_token", "Bearer abcdefghijklmnop"), +] + + +@pytest.mark.parametrize("label,value", FORBIDDEN_VALUES, ids=[x[0] for x in FORBIDDEN_VALUES]) +def test_forbidden_values_are_rejected(label, value): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope("bot_creative_work", index=f"bad:{label}") + envelope["payload"] = dict(envelope["payload"], note=value) + result = archive_like_companion(service, envelope) + assert result["ok"] is False, f"{label} 应被拒绝: {value!r}" + assert result["error_code"] == "privacy_rejected", result + service.store.close() + + +ALLOWED_VALUES = [ + ("chinese_sentence", "今天把机房的机柜标签重新打印了一遍,顺手理了理走线。"), + ("relative_path", "文档在 docs/a.md 里"), + ("dot_relative_path", "脚本是 ./scripts/run.sh"), + ("https_url", "参考 https://example.com/guide 这一篇"), + ("time_range", "09:00-10:00 之间完成"), + ("ratio_with_colon", "data:统计口径按窗口聚合"), + ("plain_word_base64", "这段说明里提到了 base64 编码的概念"), + ("colon_text", "结论: 部署稳定"), + ("version_text", "版本 v1.2.3 已发布"), +] + + +@pytest.mark.parametrize("label,value", ALLOWED_VALUES, ids=[x[0] for x in ALLOWED_VALUES]) +def test_normal_values_are_not_false_positives(label, value): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope("bot_creative_work", index=f"ok:{label}") + envelope["payload"] = dict(envelope["payload"], note=value) + result = archive_like_companion(service, envelope) + assert result["ok"] is True, f"{label} 被误杀: {value!r} -> {result}" + service.store.close() + + +def test_hardened_patterns_add_no_new_error_code(): + """M3:加固只复用 privacy_rejected,capability 清单无需变动。""" + service = object.__new__(MemoryCompanionService) + service.config = Config() + declared = set(service.bridge_probe_bot_personal_memory_capabilities()["error_codes"]) + assert "privacy_rejected" in declared + with tempfile.TemporaryDirectory() as temp: + live = make_service(temp) + envelope = real_shape_envelope("bot_creative_work", index="codes") + envelope["payload"] = dict(envelope["payload"], note="data:image/png;base64,AAAA") + result = archive_like_companion(live, envelope) + assert result["error_code"] in declared + live.store.close() + + +def test_rejected_payload_leaves_no_row_behind(): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope("bot_creative_work", index="norow") + envelope["payload"] = dict(envelope["payload"], note="D:\\private\\a.png") + result = archive_like_companion(service, envelope) + assert result["ok"] is False + rows = service.store._conn.execute( + "SELECT COUNT(*) FROM memories WHERE memory_domain='bot_self_schedule'").fetchone()[0] + assert rows == 0 + service.store.close() + + +def test_stored_legacy_record_carries_no_local_path_or_base64(): + """写入成功的记录整行 dump 里不得出现路径/base64 痕迹。""" + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + envelope = real_shape_envelope("bot_proactive_message", index="clean") + envelope["payload"] = dict(envelope["payload"], has_image=True, image_name="jifang.png") + result = archive_like_companion(service, envelope) + assert result["ok"] is True, result + service.store._conn.row_factory = None + dump = json.dumps([list(map(str, row)) for row in service.store._conn.execute( + "SELECT * FROM memories WHERE memory_domain='bot_self_schedule'")], ensure_ascii=False) + for marker in ("base64,", "-----BEGIN", "D:\\", "/home/", "/tmp/"): + assert marker not in dump, marker + assert "jifang.png" in dump + service.store.close() diff --git a/tests/test_m6_r4_creative_media_domain.py b/tests/test_m6_r4_creative_media_domain.py new file mode 100644 index 0000000..493737d --- /dev/null +++ b/tests/test_m6_r4_creative_media_domain.py @@ -0,0 +1,195 @@ +"""M6.1.4 创作 / 媒体 / 主观记忆分域回归(记忆侧)。 + +对应队列第 7 节「记忆插件」四条:独立 schema/索引/过滤、保留来源链不压成字符串、 +限制媒体引用路径、mixed 活动显式拆分不得同时进用户域与 Bot 域。 +""" +import asyncio +import json +import tempfile +from pathlib import Path + +import pytest + +from core.bot_personal import BOT_PERSONAL_TYPE_CONTRACTS +from core.service import MemoryCompanionService +from core.store import MemoryStore + +OCCURRED = "2026-07-27T18:00:00+08:00" + + +class Config: + def __init__(self, enabled=True): + self.enabled = enabled + + def bool(self, key, default=True): + return self.enabled + + +def make_service(temp_dir): + service = object.__new__(MemoryCompanionService) + service.config = Config() + service.store = MemoryStore(Path(temp_dir) / "memory.db") + service.store.initialize() + service._schedule_memory_embedding = lambda *args, **kwargs: None + return service + + +@pytest.fixture +def service(): + """断言失败时也要关库:否则 Windows 删不掉 memory.db,PermissionError 会盖住真正的失败。""" + with tempfile.TemporaryDirectory() as temp: + svc = make_service(temp) + try: + yield svc + finally: + svc.store.close() + + +def archive(service, memory_type, body, *, key="k1", occurred_at=OCCURRED, evidence="L1"): + """复刻陪伴侧非五类的通用回退调用形状。""" + envelope = { + "record_id": f"local:{key}", "memory_domain": "bot_self_schedule", + "memory_type": memory_type, "subject": "bot_self", "date": occurred_at[:10], + "window": "evening", "occurred_at": occurred_at, "created_at": occurred_at, + "updated_at": occurred_at, "source_kind": BOT_PERSONAL_TYPE_CONTRACTS[memory_type]["source_kind"], + "source_refs": [f"ref:{key}"], "certainty": 0.6, "evidence_level": evidence, + "status": "active", "version": 1, "idempotency_key": key, + "payload_schema_version": "1.0", "payload": body, + } + return asyncio.run(service.record_bot_personal_memory( + memory_type=memory_type, payload=envelope["payload"], occurred_at=envelope["occurred_at"], + idempotency_key=envelope["idempotency_key"], source_refs=list(envelope["source_refs"]), + date=envelope["date"], window=envelope["window"], certainty=envelope["certainty"], + evidence_level=envelope["evidence_level"], version=envelope["version"], + payload_schema_version="1.0", status=envelope["status"], source_plugin="private_companion")) + + +# -------------------------------------------------------------------------- +# 1. 独立 schema / 索引 / 过滤 +# -------------------------------------------------------------------------- + +def test_creative_media_subjective_have_distinct_contracts(): + """三类不能共用同一套真实性标注,否则检索侧无法分域过滤。""" + creative = BOT_PERSONAL_TYPE_CONTRACTS["bot_creative_work"] + media = BOT_PERSONAL_TYPE_CONTRACTS["bot_media_memory"] + subjective = BOT_PERSONAL_TYPE_CONTRACTS["bot_subjective_memory"] + levels = {creative["reality_level"], media["reality_level"], subjective["reality_level"]} + kinds = {creative["source_kind"], media["source_kind"], subjective["source_kind"]} + assert levels == {"creative_work", "media_index", "subjective"} + assert kinds == {"creative", "media", "subjective"} + + +def test_domain_type_time_index_exists(service): + names = {row[0] for row in service.store._conn.execute( + "SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='memories'")} + assert "idx_memories_domain_type_time" in names + + +def test_each_type_is_filterable_on_its_own(service): + for i, mt in enumerate(("bot_creative_work", "bot_media_memory", "bot_subjective_memory")): + assert archive(service, mt, {"summary": f"s{i}"}, key=f"k{i}")["ok"] is True + for mt, expected in (("bot_creative_work", 1), ("bot_media_memory", 1), ("bot_subjective_memory", 1)): + rows = service.store._conn.execute( + "SELECT COUNT(*) FROM memories WHERE memory_domain='bot_self_schedule' AND memory_type=?", + (mt,)).fetchone()[0] + assert rows == expected, mt + + +def test_subjective_types_are_marked_epistemically(service): + for mt in ("bot_subjective_memory", "bot_daily_diary"): + result = archive(service, mt, {"summary": "梦/日记"}, key=f"sub:{mt}") + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.metadata["epistemic_type"] == "subjective", mt + creative = archive(service, "bot_creative_work", {"summary": "创作"}, key="cw") + record = asyncio.run(service.store.get_memory(creative["record_id"])) + assert record.metadata["epistemic_type"] == "creative" + + +# -------------------------------------------------------------------------- +# 2. 保留来源链,不把结构化对象压成字符串 +# -------------------------------------------------------------------------- + +def test_structured_body_survives_round_trip(service): + body = { + "project_id": "novel-1", "current_chars": 2400, "chunk_index": 2, + "threads": ["线索甲", "线索乙"], + "important": ["事实甲"], + "nested": {"a": 1, "b": [1, 2, 3]}, + } + result = archive(service, "bot_creative_work", body, key="chain") + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.metadata["threads"] == ["线索甲", "线索乙"], "列表被压成字符串" + assert record.metadata["nested"] == {"a": 1, "b": [1, 2, 3]}, "嵌套对象被压平" + assert record.metadata["current_chars"] == 2400 + assert isinstance(record.metadata["current_chars"], int), "数字被转成字符串" + + +def test_source_refs_stay_a_list_not_a_joined_string(service): + result = archive(service, "bot_media_memory", {"media_id": "abc"}, key="refs") + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.metadata["source_refs"] == ["ref:refs"] + assert isinstance(record.metadata["source_refs"], list) + + +# -------------------------------------------------------------------------- +# 3. 限制媒体引用路径 +# -------------------------------------------------------------------------- + +MEDIA_PATH_CASES = [ + ("windows_abs", {"media_path": "D:\\astrbot\\media\\a.png"}), + ("posix_abs", {"media_path": "/home/bot/media/a.png"}), + ("path_after_colon", {"note": "存在:D:\\media\\a.png"}), + ("data_uri", {"thumbnail": "data:image/png;base64,AAAA"}), + ("base64_infix", {"note": "缩略图 base64,AAAA"}), +] + + +@pytest.mark.parametrize("label,body", MEDIA_PATH_CASES, ids=[c[0] for c in MEDIA_PATH_CASES]) +def test_media_records_reject_local_paths_and_binaries(service, label, body): + result = archive(service, "bot_media_memory", dict(body, media_id="abc"), key=f"bad:{label}") + assert result["ok"] is False, f"{label} 应被拒绝" + assert result["error_code"] == "privacy_rejected", result + rows = service.store._conn.execute("SELECT COUNT(*) FROM memories").fetchone()[0] + assert rows == 0 + + +def test_media_index_fields_are_accepted(service): + """只存标识/名称/类型/尺寸的媒体索引必须能落库,否则合同要求无法实现。""" + result = archive(service, "bot_media_memory", { + "media_id": "9f8e7d6c5b4a3210", "media_kind": "generated_image", + "media_name": "out_001.png", "width": 1024, "height": 1024, + "mime": "image/png", "summary": "机房夜景里的猫", + }, key="media:ok") + assert result["ok"] is True, result + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.metadata["media_name"] == "out_001.png" + assert record.metadata["width"] == 1024 + assert record.reality_level == "media_index" + + +# -------------------------------------------------------------------------- +# 4. mixed 活动不得同时进用户域与 Bot 域 +# -------------------------------------------------------------------------- + +def test_bot_personal_records_are_pinned_to_the_bot_domain(service): + result = archive(service, "bot_shared_activity", { + "summary": "和主人一起排障", + # 调用方即使谎报域/主体,也不得越界 + "memory_domain": "user_facts", "scope": "private", "subject": {"kind": "user", "id": "u1"}, + }, key="mixed") + assert result["ok"] is True, result + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.memory_domain == "bot_self_schedule" + assert record.subject.kind == "bot" + assert record.object.kind == "bot" + rows = service.store._conn.execute( + "SELECT COUNT(*) FROM memories WHERE memory_domain!='bot_self_schedule'").fetchone()[0] + assert rows == 0, "同一条记录同时出现在用户域" + + +def test_shared_activity_keeps_its_own_reality_level(service): + result = archive(service, "bot_shared_activity", {"summary": "共同活动"}, key="shared") + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.reality_level == "shared_activity" + assert record.metadata["source_kind"] == "shared" + assert record.metadata["source_kind"] != "observed" diff --git a/tests/test_m6_r5_bot_profiles.py b/tests/test_m6_r5_bot_profiles.py new file mode 100644 index 0000000..75fbd49 --- /dev/null +++ b/tests/test_m6_r5_bot_profiles.py @@ -0,0 +1,280 @@ +"""M6.1.5 Bot 专用检索 Profile 回归(记忆侧)。 + +Profile 的价值全在「固定」二字:域、类型、时间范围、条数、排序、注入字段、权限 +一旦有一项可以被调用方绕过,专用检索就退回成全库通用检索。本模块逐项钉死这七件事, +外加队列第 8 节的三条出口条件。 +""" +import asyncio +import tempfile +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import pytest + +from core.bot_personal import BOT_PERSONAL_TYPE_CONTRACTS +from core.bot_profiles import BOT_PROFILE_NAMES, BOT_RETRIEVAL_PROFILES, describe_bot_profiles +from core.bridge import MemoryCompanionBridge +from core.models import EntityRef, MemoryRecord +from core.service import MemoryCompanionService +from core.store import MemoryStore + +TZ = timezone(timedelta(hours=8)) +NOW = datetime(2026, 7, 27, 18, 0, 0, tzinfo=TZ) + + +class Config: + def bool(self, key, default=True): + return True + + def int(self, key, default=0): + return default + + def text(self, key, default=""): + return default + + +def make_service(temp_dir): + service = object.__new__(MemoryCompanionService) + service.config = Config() + service.store = MemoryStore(Path(temp_dir) / "memory.db") + service.store.initialize() + service._schedule_memory_embedding = lambda *args, **kwargs: None + return service + + +@pytest.fixture +def service(): + with tempfile.TemporaryDirectory() as temp: + svc = make_service(temp) + try: + yield svc + finally: + svc.store.close() + + +def archive(service, memory_type, *, key, days_ago=0, summary="记录"): + occurred = (NOW - timedelta(days=days_ago)).isoformat() + return asyncio.run(service.record_bot_personal_memory( + memory_type=memory_type, + payload={"summary": summary}, + occurred_at=occurred, idempotency_key=key, source_refs=[f"ref:{key}"], + date=occurred[:10], window="evening", certainty=0.6, + evidence_level="L0" if memory_type == "bot_schedule_plan" else "L1", + version=1, payload_schema_version="1.0", status="active", + source_plugin="private_companion")) + + +def search(service, profile, **kwargs): + return asyncio.run(service.search_bot_personal_profile(profile, "", now=NOW, **kwargs)) + + +# -------------------------------------------------------------------------- +# Profile 契约本身 +# -------------------------------------------------------------------------- + +def test_five_profiles_are_defined(): + assert set(BOT_PROFILE_NAMES) == { + "bot_schedule_current", "bot_schedule_history", + "bot_creative", "bot_subjective", "locked_frame_personal"} + + +@pytest.mark.parametrize("name", BOT_PROFILE_NAMES) +def test_every_profile_pins_all_seven_dimensions(name): + spec = BOT_RETRIEVAL_PROFILES[name] + described = describe_bot_profiles()[name] + assert described["memory_domain"] == "bot_self_schedule" # 允许域 + assert spec["memory_types"] # 类型 + assert "min_age_days" in spec and "max_age_days" in spec # 时间范围 + assert isinstance(spec["limit"], int) and spec["limit"] > 0 # 最大条数 + assert spec["order"] == "occurred_at_desc" # 排序 + assert spec["fields"] # 注入字段 + assert described["read_only"] is True # 权限 + + +@pytest.mark.parametrize("name", BOT_PROFILE_NAMES) +def test_profile_types_are_all_real_contract_types(name): + for memory_type in BOT_RETRIEVAL_PROFILES[name]["memory_types"]: + assert memory_type in BOT_PERSONAL_TYPE_CONTRACTS, memory_type + + +def test_current_and_history_windows_do_not_overlap(): + """重叠的话同一条记录会既算「现在」又算「过去」,模型分不清该照做还是回忆。""" + current = BOT_RETRIEVAL_PROFILES["bot_schedule_current"] + history = BOT_RETRIEVAL_PROFILES["bot_schedule_history"] + assert current["max_age_days"] <= history["min_age_days"] + + +# -------------------------------------------------------------------------- +# 时间范围 +# -------------------------------------------------------------------------- + +def test_current_profile_only_returns_recent_records(service): + archive(service, "bot_observed_activity", key="today", days_ago=0, summary="今天做的事") + archive(service, "bot_observed_activity", key="old", days_ago=5, summary="五天前做的事") + result = search(service, "bot_schedule_current") + contents = " ".join(m.get("content", "") for m in result["memories"]) + assert "今天做的事" in contents + assert "五天前做的事" not in contents + + +def test_history_profile_excludes_today(service): + archive(service, "bot_observed_activity", key="today", days_ago=0, summary="今天做的事") + archive(service, "bot_observed_activity", key="old", days_ago=5, summary="五天前做的事") + result = search(service, "bot_schedule_history") + contents = " ".join(m.get("content", "") for m in result["memories"]) + assert "五天前做的事" in contents + assert "今天做的事" not in contents, "历史 Profile 不得把当前记录当成过去返回" + + +def test_many_recent_records_do_not_starve_the_history_profile(service): + """时间窗必须进 SQL。 + + 在 Python 里后筛的话,「按 occurred_at 倒序取 N 条再过滤」会让近期记录把名额占满, + 历史窗里的行根本进不了结果集,Profile 静默返回空——联合 E2E 里就是这么暴露出来的。 + """ + for i in range(60): + archive(service, "bot_observed_activity", key=f"recent{i}", days_ago=0, summary=f"今天第{i}件事") + archive(service, "bot_observed_activity", key="buried", days_ago=3, summary="三天前被埋掉的事") + memories = search(service, "bot_schedule_history")["memories"] + assert memories, "历史 Profile 不应因近期记录过多而返回空" + assert any("三天前被埋掉的事" in m.get("content", "") for m in memories) + + +def test_records_outside_max_age_are_dropped(service): + archive(service, "bot_subjective_memory", key="ancient", days_ago=400, summary="很久以前的梦") + assert search(service, "bot_subjective")["memories"] == [] + + +def test_records_without_timezone_are_dropped(service): + """时间定位不了的记录,宁可不注入,也不能被当成「当前」。""" + record = MemoryRecord( + id="botmem_naive", memory_type="bot_observed_activity", memory_domain="bot_self_schedule", + subject=EntityRef.bot_self(), object=EntityRef.bot_self(), scope="private", + session_id="bot_personal", visibility="bot_self", sayability="indirect", + reality_level="observed_activity", lifecycle="stable_memory", content="没有时区的记录", + evidence="x", confidence=0.8, importance=0.5, tags=["bot_personal"], + metadata={"memory_domain": "bot_self_schedule"}, source_plugin="private_companion", + occurred_at="2026-07-27T18:00:00") + asyncio.run(service.store.upsert_bot_personal_memory( + record, payload_fingerprint="fp", version=1, idempotency_key="naive")) + result = search(service, "bot_schedule_current") + assert all("没有时区" not in m.get("content", "") for m in result["memories"]) + + +# -------------------------------------------------------------------------- +# 类型、条数、排序 +# -------------------------------------------------------------------------- + +def test_each_profile_returns_only_its_own_types(service): + for i, mt in enumerate(BOT_PERSONAL_TYPE_CONTRACTS): + archive(service, mt, key=f"t{i}", days_ago=0) + for name, spec in BOT_RETRIEVAL_PROFILES.items(): + if spec["min_age_days"]: + continue # 历史 Profile 的窗口里没有今天的记录 + result = search(service, name) + returned = {m["memory_type"] for m in result["memories"]} + assert returned <= set(spec["memory_types"]), (name, returned) + + +def test_limit_can_be_lowered_but_not_raised(service): + for i in range(9): + archive(service, "bot_observed_activity", key=f"n{i}", days_ago=0) + assert len(search(service, "bot_schedule_current", limit=2)["memories"]) == 2 + # 试图突破 Profile 上限(6)应被夹住 + raised = search(service, "bot_schedule_current", limit=99) + assert raised["limit"] == BOT_RETRIEVAL_PROFILES["bot_schedule_current"]["limit"] + assert len(raised["memories"]) <= 6 + + +def test_results_are_ordered_newest_first(service): + archive(service, "bot_creative_work", key="a", days_ago=10, summary="较早创作") + archive(service, "bot_creative_work", key="b", days_ago=2, summary="较晚创作") + memories = search(service, "bot_creative")["memories"] + assert len(memories) == 2 + assert memories[0]["occurred_at"] > memories[1]["occurred_at"] + + +# -------------------------------------------------------------------------- +# 注入字段与权限 +# -------------------------------------------------------------------------- + +INTERNAL_FIELDS = ("payload_fingerprint", "idempotency_key", "persona_importance", + "relationship_weight", "content_fingerprint", "evidence") + + +def test_projection_drops_internal_fields(service): + archive(service, "bot_observed_activity", key="proj", days_ago=0) + item = search(service, "bot_schedule_current")["memories"][0] + for field in INTERNAL_FIELDS: + assert field not in item, field + assert set(item) <= set(BOT_RETRIEVAL_PROFILES["bot_schedule_current"]["fields"]) + + +def test_subjective_profile_exposes_epistemic_type(service): + archive(service, "bot_subjective_memory", key="dream", days_ago=0, summary="梦到机房飘雪") + item = search(service, "bot_subjective")["memories"][0] + assert item["epistemic_type"] == "subjective", "主观内容必须可被识别为主观" + + +def test_profiles_are_read_only(service): + assert search(service, "bot_creative")["read_only"] is True + + +def test_unknown_profile_returns_empty_with_warning(service): + result = search(service, "全库随便搜") + assert result["memories"] == [] + assert "unknown_profile" in result["warnings"] + + +# -------------------------------------------------------------------------- +# 出口条件 +# -------------------------------------------------------------------------- + +def test_profiles_never_return_user_memories(service): + """出口条件:用户事实查询不返回 Bot 内容,反过来 Profile 也不得返回用户记忆。""" + user_record = MemoryRecord( + id="usr_1", memory_type="user_fact", memory_domain="user_memory", + subject=EntityRef(kind="user", id="u1"), object=EntityRef.bot_self(), scope="private", + session_id="bot_personal", visibility="bot_self", sayability="direct", + reality_level="real_user_fact", lifecycle="stable_memory", content="用户喜欢喝美式", + evidence="x", confidence=0.9, importance=0.6, tags=["user"], + metadata={"memory_domain": "user_memory"}, source_plugin="memory_companion", + occurred_at=NOW.isoformat()) + asyncio.run(service.store.insert_memory(user_record)) + for name in BOT_PROFILE_NAMES: + result = search(service, name) + assert all("美式" not in m.get("content", "") for m in result["memories"]), name + + +def test_capability_publishes_the_profile_contract(service): + cap = service.bridge_probe_bot_personal_memory_capabilities() + assert set(cap["retrieval_profiles"]) == set(BOT_PROFILE_NAMES) + assert "search_bot_schedule" in cap["retrieval_methods"] + assert cap["retrieval_profiles"]["bot_creative"]["read_only"] is True + + +# -------------------------------------------------------------------------- +# Bridge 具名入口 +# -------------------------------------------------------------------------- + +def test_named_bridge_methods_map_to_the_right_profiles(service): + bridge = MemoryCompanionBridge(service) + cases = ( + (lambda: bridge.search_bot_schedule(""), "bot_schedule_current"), + (lambda: bridge.search_bot_schedule("", history=True), "bot_schedule_history"), + (lambda: bridge.search_bot_creative_memory(""), "bot_creative"), + (lambda: bridge.search_bot_subjective_memory(""), "bot_subjective"), + (lambda: bridge.search_locked_frame_personal_memory(""), "locked_frame_personal"), + ) + for call, expected in cases: + assert asyncio.run(call())["profile"] == expected + + +def test_bridge_reports_unavailable_when_plugin_lacks_profiles(): + """旧版记忆插件没有 Profile 方法时要给出稳定信号,好让陪伴侧回退。""" + class Plugin: + pass + bridge = MemoryCompanionBridge(Plugin()) + result = asyncio.run(bridge.search_bot_personal_profile("bot_creative")) + assert result["memories"] == [] + assert "bridge_method_unavailable" in result["warnings"] diff --git a/tests/test_m6_r6_bot_archive_api.py b/tests/test_m6_r6_bot_archive_api.py new file mode 100644 index 0000000..7b44283 --- /dev/null +++ b/tests/test_m6_r6_bot_archive_api.py @@ -0,0 +1,198 @@ +"""M6.1.6 记忆侧 Bot 归档只读 API 回归。 + +队列第 9 节的页面规则里有两条是硬约束: +- 长期归档标明来自记忆插件(响应必须自带来源标识); +- 页面只调稳定只读 API,不访问另一个插件私有对象。 + +这里直接调 PageAPI 的处理函数,绕开 HTTP 层但走真实实现,验证契约本身。 +""" +import asyncio +import sys +import tempfile +import types +from datetime import datetime, timedelta, timezone +from pathlib import Path +from types import SimpleNamespace + +import pytest + +from core.bot_profiles import BOT_PROFILE_NAMES +from core.models import EntityRef, MemoryRecord +from core.service import MemoryCompanionService +from core.store import MemoryStore + +# page_api 在导入期就需要 quart;本仓不带 Web 依赖,按其它测试同款方式打桩。 +if "quart" not in sys.modules: + _quart = types.ModuleType("quart") + _quart.jsonify = lambda body: body + _quart.request = types.SimpleNamespace(args={}) + _quart.send_file = lambda *a, **k: None + sys.modules["quart"] = _quart + +import page_api as page_api_module + +TZ = timezone(timedelta(hours=8)) +NOW = datetime(2026, 7, 27, 18, 0, 0, tzinfo=TZ) + + +class Config: + def bool(self, key, default=True): + return True + + def int(self, key, default=0): + return default + + def text(self, key, default=""): + return default + + +class FakeRequest: + """替代 quart.request:只提供 args。""" + + def __init__(self, args=None): + self.args = dict(args or {}) + + +class Recorded: + """替代 quart.jsonify:原样返回 dict,方便断言。""" + + @staticmethod + def jsonify(body): + return body + + +def make_service(temp_dir): + service = object.__new__(MemoryCompanionService) + service.config = Config() + service.store = MemoryStore(Path(temp_dir) / "memory.db") + service.store.initialize() + service._schedule_memory_embedding = lambda *args, **kwargs: None + return service + + +@pytest.fixture +def api(monkeypatch): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + monkeypatch.setattr(page_api_module, "jsonify", Recorded.jsonify) + instance = object.__new__(page_api_module.PluginPageApi) + instance.plugin = SimpleNamespace(service=service) + try: + yield instance, service, monkeypatch + finally: + service.store.close() + + +def archive(service, memory_type, *, key, days_ago=0, summary="记录"): + occurred = (NOW - timedelta(days=days_ago)).isoformat() + return asyncio.run(service.record_bot_personal_memory( + memory_type=memory_type, payload={"summary": summary}, occurred_at=occurred, + idempotency_key=key, source_refs=[f"ref:{key}"], date=occurred[:10], window="evening", + certainty=0.6, evidence_level="L0" if memory_type == "bot_schedule_plan" else "L1", + version=1, payload_schema_version="1.0", status="active", source_plugin="private_companion")) + + +def call(api_bundle, handler_name, args=None): + instance, _, monkeypatch = api_bundle + monkeypatch.setattr(page_api_module, "request", FakeRequest(args)) + return asyncio.run(getattr(instance, handler_name)()) + + +# -------------------------------------------------------------------------- + +def test_profiles_endpoint_publishes_the_contract(api): + body = call(api, "bot_archive_profiles") + assert body["success"] is True + assert set(body["profiles"]) == set(BOT_PROFILE_NAMES) + assert body["read_only"] is True + + +def test_every_response_declares_it_comes_from_the_memory_plugin(api): + """页面必须能区分「运行态来自陪伴」和「长期归档来自记忆」。""" + for handler, args in (("bot_archive_profiles", None), + ("bot_archive_query", {"profile": "bot_creative"}), + ("bot_archive_locked_frame", None)): + body = call(api, handler, args) + assert body["data_source"] == "memory_archive", handler + assert body["source_plugin"] == "memory_companion", handler + + +def test_query_returns_only_the_requested_profile(api): + _, service, _ = api + archive(service, "bot_creative_work", key="c1", summary="小说推进") + archive(service, "bot_subjective_memory", key="d1", summary="梦到机房飘雪") + body = call(api, "bot_archive_query", {"profile": "bot_creative"}) + contents = " ".join(m.get("content", "") for m in body["memories"]) + assert "小说推进" in contents + assert "梦到机房飘雪" not in contents + assert body["read_only"] is True + assert body["memory_domain"] == "bot_self_schedule" + + +def test_query_rejects_unknown_profile_without_falling_back_to_everything(api): + _, service, _ = api + archive(service, "bot_creative_work", key="c1", summary="小说推进") + body = call(api, "bot_archive_query", {"profile": "全库随便搜"}) + assert body["memories"] == [] + assert "unknown_profile" in body["warnings"] + + +def test_query_limit_cannot_exceed_the_profile_cap(api): + _, service, _ = api + for i in range(9): + archive(service, "bot_creative_work", key=f"c{i}", summary=f"创作{i}") + body = call(api, "bot_archive_query", {"profile": "bot_creative", "limit": "999"}) + assert body["limit"] == 6 + assert len(body["memories"]) <= 6 + + +def test_locked_frame_groups_by_memory_type(api): + _, service, _ = api + archive(service, "bot_creative_work", key="c1", summary="小说推进") + archive(service, "bot_subjective_memory", key="d1", summary="梦到机房飘雪") + body = call(api, "bot_archive_locked_frame") + assert set(body["groups"]) == {"bot_creative_work", "bot_subjective_memory"} + assert body["total"] == 2 + assert body["profile"] == "locked_frame_personal" + + +def test_bot_archive_never_exposes_user_memories(api): + _, service, _ = api + user_record = MemoryRecord( + id="usr_1", memory_type="user_fact", memory_domain="user_memory", + subject=EntityRef(kind="user", id="u1"), object=EntityRef.bot_self(), scope="private", + session_id="bot_personal", visibility="bot_self", sayability="direct", + reality_level="real_user_fact", lifecycle="stable_memory", content="用户喜欢喝美式", + evidence="x", confidence=0.9, importance=0.6, tags=["user"], + metadata={"memory_domain": "user_memory"}, source_plugin="memory_companion", + occurred_at=NOW.isoformat()) + asyncio.run(service.store.insert_memory(user_record)) + for handler, args in (("bot_archive_query", {"profile": "locked_frame_personal"}), + ("bot_archive_locked_frame", None)): + body = call(api, handler, args) + assert "美式" not in str(body), handler + + +def test_bot_archive_endpoints_expose_no_internal_fields(api): + _, service, _ = api + archive(service, "bot_creative_work", key="c1", summary="小说推进") + body = call(api, "bot_archive_query", {"profile": "bot_creative"}) + for item in body["memories"]: + for field in ("payload_fingerprint", "idempotency_key", "evidence", "persona_importance"): + assert field not in item, field + + +def test_bot_archive_endpoints_are_registered_get_only(api): + """只读端点不得注册写方法——Bot 域的写入只走受控归档路径。""" + instance, service, _ = api + registered = [] + instance.plugin = SimpleNamespace( + service=service, + context=SimpleNamespace( + register_web_api=lambda path, handler, methods, desc: registered.append((path, tuple(methods)))), + ) + instance.register_routes() + bot_routes = [(path, methods) for path, methods in registered if "/bot-archive/" in path] + assert len(bot_routes) == 3, bot_routes + for path, methods in bot_routes: + assert methods == ("GET",), path diff --git a/tests/test_m6_r7_domain_isolation.py b/tests/test_m6_r7_domain_isolation.py new file mode 100644 index 0000000..fde3e6e --- /dev/null +++ b/tests/test_m6_r7_domain_isolation.py @@ -0,0 +1,315 @@ +"""M6.1.7 三域隔离、通用写入拒绝与页面状态码回归(记忆侧)。 + +对应队列第 10 节「记忆插件主责」第 2/3/4 条: +- 用户域 / Bot 域 / mixed 域在查询、页面、Bridge、导出四层的隔离; +- Bot 域通用修改/删除明确拒绝,只允许受控归档路径写入; +- 页面 API 的真实 HTTP 状态码。 + +管理会话与 Origin/CSRF 由 AstrBot 宿主的 `register_web_api` 提供,插件不自建第二套; +本模块只钉住插件自己能控的部分:写入端点一律 POST(不可被跨站的普通链接触发)、 +错误路径返回正确状态码。宿主鉴权在 VM 实机验收核对。 +""" +import asyncio +import json +import sys +import tempfile +import types +from datetime import datetime, timedelta, timezone +from pathlib import Path +from types import SimpleNamespace + +import pytest + +from core.bridge import MemoryCompanionBridge +from core.models import EntityRef, MemoryRecord +from core.operations import PortableMemoryArchive +from core.service import MemoryCompanionService +from core.store import MemoryStore +from core.user_memory_boundary import USER_MEMORY_DOMAIN + +if "quart" not in sys.modules: + _quart = types.ModuleType("quart") + _quart.jsonify = lambda body: body + _quart.request = types.SimpleNamespace(args={}) + _quart.send_file = lambda *a, **k: None + sys.modules["quart"] = _quart + +import page_api as page_api_module + +TZ = timezone(timedelta(hours=8)) +NOW = datetime(2026, 7, 27, 18, 0, 0, tzinfo=TZ) +BOT_DOMAIN = "bot_self_schedule" + + +class Response(dict): + """替代 quart 响应:既是 dict 又能挂 status_code。""" + + status_code = 200 + + +def _jsonify(body): + response = Response(body) + response.status_code = 200 + return response + + +class Config: + def bool(self, key, default=True): + return True + + def int(self, key, default=0): + return default + + def text(self, key, default=""): + return default + + +class FakeRequest: + def __init__(self, args=None, body=None): + self.args = dict(args or {}) + self._body = dict(body or {}) + + async def get_json(self, silent=False): + return self._body + + +def make_service(temp_dir): + service = object.__new__(MemoryCompanionService) + service.config = Config() + service.store = MemoryStore(Path(temp_dir) / "memory.db") + service.store.initialize() + service._schedule_memory_embedding = lambda *args, **kwargs: None + service.portable_archive = PortableMemoryArchive(service.store, temp_dir) + return service + + +@pytest.fixture +def api(monkeypatch): + with tempfile.TemporaryDirectory() as temp: + service = make_service(temp) + monkeypatch.setattr(page_api_module, "jsonify", _jsonify) + instance = object.__new__(page_api_module.PluginPageApi) + instance.plugin = SimpleNamespace(service=service) + try: + yield instance, service, monkeypatch + finally: + service.store.close() + + +def call(bundle, handler, args=None, body=None): + instance, _, monkeypatch = bundle + monkeypatch.setattr(page_api_module, "request", FakeRequest(args, body)) + return asyncio.run(getattr(instance, handler)()) + + +def archive_bot(service, memory_type="bot_creative_work", *, key="b1", summary="创作里程碑"): + occurred = NOW.isoformat() + result = asyncio.run(service.record_bot_personal_memory( + memory_type=memory_type, payload={"summary": summary}, occurred_at=occurred, + idempotency_key=key, source_refs=[f"ref:{key}"], date=occurred[:10], window="evening", + certainty=0.6, evidence_level="L1", version=1, payload_schema_version="1.0", + status="active", source_plugin="private_companion")) + assert result["ok"] is True, result + return result["record_id"] + + +def insert_user(service, memory_id="usr_1", content="用户喜欢喝美式"): + record = MemoryRecord( + id=memory_id, memory_type="user_fact", memory_domain=USER_MEMORY_DOMAIN, + subject=EntityRef(kind="user", id="u1"), object=EntityRef.bot_self(), scope="private", + session_id="s1", visibility="private_pair", sayability="direct", + reality_level="real_user_fact", lifecycle="stable_memory", content=content, + evidence="x", confidence=0.9, importance=0.6, tags=["user"], metadata={}, + source_plugin="memory_companion", occurred_at=NOW.isoformat()) + asyncio.run(service.store.insert_memory(record)) + return memory_id + + +# -------------------------------------------------------------------------- +# 第 3 条:Bot 域通用修改/删除明确拒绝 +# -------------------------------------------------------------------------- + +@pytest.mark.parametrize("handler,body_extra", [ + ("memory_delete", {}), + ("memory_update", {"content": "被改写的内容"}), + ("memory_lifecycle", {"lifecycle": "archived"}), + ("memory_visibility", {"visibility": "private_pair"}), +]) +def test_generic_write_endpoints_reject_bot_domain(api, handler, body_extra): + _, service, _ = api + record_id = archive_bot(service) + response = call(api, handler, body=dict(body_extra, id=record_id)) + assert response.status_code == 409, (handler, response) + assert response["success"] is False + assert "locked" in response["error"], response + + +def test_rejected_write_leaves_the_bot_record_untouched(api): + _, service, _ = api + record_id = archive_bot(service, summary="原始里程碑") + call(api, "memory_delete", body={"id": record_id}) + call(api, "memory_update", body={"id": record_id, "content": "被改写"}) + record = asyncio.run(service.store.get_memory(record_id)) + assert record is not None, "Bot 归档记录被通用删除端点删掉了" + assert "原始里程碑" in record.content + assert record.memory_domain == BOT_DOMAIN + + +def test_user_domain_writes_still_work(api): + """拒绝只针对 Bot 域,用户记忆的正常管理不能被误伤。""" + _, service, _ = api + memory_id = insert_user(service) + updated = call(api, "memory_update", body={"id": memory_id, "content": "用户改喝手冲"}) + assert updated["success"] is True, updated + deleted = call(api, "memory_delete", body={"id": memory_id}) + assert deleted["success"] is True + assert deleted["deleted"] is True + assert asyncio.run(service.store.get_memory(memory_id)) is None + + +def test_controlled_archive_path_still_writes_bot_records(api): + """封的是通用入口,不是归档能力本身。""" + _, service, _ = api + first = archive_bot(service, key="ctl", summary="第一版") + again = asyncio.run(service.record_bot_personal_memory( + memory_type="bot_creative_work", payload={"summary": "第二版"}, + occurred_at=NOW.isoformat(), idempotency_key="ctl", source_refs=["ref:ctl"], + date=NOW.date().isoformat(), window="evening", certainty=0.6, evidence_level="L1", + version=2, payload_schema_version="1.0", status="active", source_plugin="private_companion")) + assert again["ok"] is True, again + assert again["record_id"] == first + assert "第二版" in asyncio.run(service.store.get_memory(first)).content + + +# -------------------------------------------------------------------------- +# 第 4 条:真实 HTTP 状态码 + 写入端点方法约束 +# -------------------------------------------------------------------------- + +@pytest.mark.parametrize("handler", ["memory_delete", "memory_update", "memory_lifecycle", "memory_visibility"]) +def test_missing_id_returns_400(api, handler): + response = call(api, handler, body={}) + assert response.status_code == 400, (handler, response) + + +@pytest.mark.parametrize("handler", ["memory_delete", "memory_update", "memory_lifecycle", "memory_visibility"]) +def test_unknown_id_returns_404(api, handler): + response = call(api, handler, body={"id": "does-not-exist"}) + assert response.status_code == 404, (handler, response) + + +def test_write_endpoints_are_post_only(api): + """写入端点不得挂在 GET 上——GET 可以被跨站的普通链接直接触发。""" + instance, service, _ = api + registered = [] + instance.plugin = SimpleNamespace( + service=service, + context=SimpleNamespace( + register_web_api=lambda path, handler, methods, desc: registered.append((path, tuple(methods)))), + ) + instance.register_routes() + # 只看真正改状态的端点。`/preview` 是只读预演;`/maintenance/sleep` 自己按方法分流 + # (GET 返回状态、POST 才执行),都不算把写操作挂在 GET 上。 + write_markers = ("/update", "/delete", "/apply", "/rollback", "/upsert", + "/clear", "/import/run", "/start", "/pause", "/resume") + offenders = [ + (path, methods) for path, methods in registered + if any(marker in path for marker in write_markers) + and "/preview" not in path and "GET" in methods + ] + assert not offenders, offenders + + +def test_read_only_bot_archive_routes_never_accept_writes(api): + instance, service, _ = api + registered = [] + instance.plugin = SimpleNamespace( + service=service, + context=SimpleNamespace( + register_web_api=lambda path, handler, methods, desc: registered.append((path, tuple(methods)))), + ) + instance.register_routes() + for path, methods in registered: + if "/bot-archive/" in path: + assert methods == ("GET",), path + + +# -------------------------------------------------------------------------- +# 第 2 条:查询、页面、Bridge、导出四层隔离 +# -------------------------------------------------------------------------- + +def test_layer_query_keeps_domains_apart(api): + _, service, _ = api + archive_bot(service, summary="Bot 的创作里程碑") + insert_user(service, content="用户喜欢喝美式") + profile = asyncio.run(service.search_bot_personal_profile("bot_creative", "", now=NOW)) + assert all("美式" not in m.get("content", "") for m in profile["memories"]) + + +def test_layer_page_keeps_domains_apart(api): + _, service, _ = api + archive_bot(service, summary="Bot 的创作里程碑") + insert_user(service, content="用户喜欢喝美式") + body = call(api, "bot_archive_query", args={"profile": "bot_creative"}) + assert "美式" not in str(body) + assert body["memory_domain"] == BOT_DOMAIN + + +def test_layer_bridge_pins_domain_even_when_caller_lies(api): + _, service, _ = api + result = asyncio.run(service.record_bot_personal_memory( + memory_type="bot_shared_activity", + payload={"summary": "共同排障", "memory_domain": USER_MEMORY_DOMAIN, + "subject": {"kind": "user", "id": "u1"}}, + occurred_at=NOW.isoformat(), idempotency_key="mixed", source_refs=["ref:mixed"], + date=NOW.date().isoformat(), window="evening", certainty=0.6, evidence_level="L1", + version=1, payload_schema_version="1.0", status="active", source_plugin="private_companion")) + assert result["ok"] is True, result + record = asyncio.run(service.store.get_memory(result["record_id"])) + assert record.memory_domain == BOT_DOMAIN + assert record.subject.kind == "bot" + rows = service.store._conn.execute( + "SELECT COUNT(*) FROM memories WHERE memory_domain=?", (USER_MEMORY_DOMAIN,)).fetchone()[0] + assert rows == 0, "mixed 活动同时进了用户域" + + +def test_layer_export_preserves_memory_domain(api): + """导出漏掉 memory_domain 的话,恢复时 bot_self_schedule 会被降级成 bot_self_legacy, + 检索 Profile 全部失效,重新归档还会撞 domain_conflict。备份恢复正好走这条路。""" + _, service, _ = api + archive_bot(service, summary="Bot 的创作里程碑") + insert_user(service) + result = asyncio.run(service.export_portable_data()) + lines = Path(result["path"]).read_text(encoding="utf-8").splitlines() + header = json.loads(lines[0]) + memories = [json.loads(line)["data"] for line in lines[1:] if json.loads(line)["record_type"] == "memory"] + domains = {m["memory_domain"] for m in memories} + assert BOT_DOMAIN in domains and USER_MEMORY_DOMAIN in domains, domains + assert header["memory_domain_counts"].get(BOT_DOMAIN) == 1 + assert header["memory_domain_counts"].get(USER_MEMORY_DOMAIN) == 1 + + +def test_layer_export_round_trip_does_not_downgrade_bot_domain(api): + _, service, _ = api + archive_bot(service, summary="Bot 的创作里程碑") + result = asyncio.run(service.export_portable_data()) + payload = next( + json.loads(line)["data"] for line in Path(result["path"]).read_text(encoding="utf-8").splitlines() + if json.loads(line)["record_type"] == "memory") + restored = PortableMemoryArchive._memory_record(payload, "batch-1") + assert restored.memory_domain == BOT_DOMAIN, "恢复后 Bot 域被降级" + + +def test_legacy_export_without_domain_still_imports(api): + """老导出没有 memory_domain 字段,必须仍能导入(回落到旧推断),不能直接崩。""" + payload = { + "id": "old_1", "memory_type": "bot_creative_work", + "subject": {"kind": "bot", "id": "self"}, "object": {"kind": "bot", "id": "self"}, + "scope": "private", "session_id": "bot_personal", "visibility": "bot_self", + "sayability": "indirect", "reality_level": "creative_work", "lifecycle": "stable_memory", + "content": "旧导出记录", "evidence": "x", "confidence": 0.8, "importance": 0.5, + "tags": [], "metadata": {}, "occurred_at": NOW.isoformat(), + } + restored = PortableMemoryArchive._memory_record(payload, "batch-old") + restored.ensure_defaults() # 与 store 写入时同款调用 + assert restored.memory_domain # 有值即可,具体值由旧推断决定 + assert restored.content == "旧导出记录"