feat: complete M6.1.3-R2 through M6.1.7 bot personal archive contract

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 <noreply@anthropic.com>
这个提交存在于:
agent-bot 2026-07-27 01:37:20 +08:00
父节点 bbd94d35a9
当前提交 e3f9e0b212
共有 19 个文件被更改,包括 3083 次插入 和 204 次删除

查看文件

@ -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))}"
summary = clean_text(payload.get("summary") or payload.get("title") or payload.get("activity") or label, 800)
return f"Bot个人归档[{label}]:{summary}"

155
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()
}

查看文件

@ -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,

查看文件

@ -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"

查看文件

@ -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),

查看文件

@ -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:

查看文件

@ -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)

查看文件

@ -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:

查看文件

@ -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}")

查看文件

@ -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 项。

查看文件

@ -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`。

查看文件

@ -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})

查看文件

@ -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()

查看文件

@ -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()

查看文件

@ -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()

查看文件

@ -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"

查看文件

@ -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"]

查看文件

@ -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

查看文件

@ -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 == "旧导出记录"