From 8d217765288406c6260f424b5cda12cdd6d3d4d1 Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Fri, 24 Jul 2026 23:06:13 +0800 Subject: [PATCH] feat: add temporal awareness to ops memory --- README.md | 7 +- core/archive_contract.py | 4 +- core/bridge.py | 21 ++- core/injection.py | 40 +++++- core/models.py | 10 +- core/service.py | 28 +++- core/temporal_context.py | 229 +++++++++++++++++++++++++++++++++ docs/时间感知兼容说明.md | 43 +++++++ docs/错题本.md | 11 +- metadata.yaml | 4 +- plugin_identity.py | 4 +- tests/test_archive_contract.py | 4 +- tests/test_temporal_context.py | 145 +++++++++++++++++++++ 13 files changed, 526 insertions(+), 24 deletions(-) create mode 100644 core/temporal_context.py create mode 100644 docs/时间感知兼容说明.md create mode 100644 tests/test_temporal_context.py diff --git a/README.md b/README.md index 8887dbb..b32cf57 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# 我会牢牢记住你・运维记忆 +# 我会牢牢记住你・运维记忆 > 当前分支:`ops-main`。这是面向个人 AstrBot VM 运维平台的专用记忆版本,与普通陪伴记忆版使用不同插件身份和数据目录。 @@ -6,7 +6,7 @@ - 插件名:`astrbot_plugin_memory_companion_ops` - 中文名:`我会牢牢记住你・运维记忆` -- 版本:`1.6.2-ops.1` +- 版本:`1.6.2-ops.2` - 适配平台:`aiocqhttp`、`qq_official` - AstrBot 版本:`>=4.22.0` - 编码要求:UTF-8 @@ -162,7 +162,8 @@ astrbot_plugin_memory_companion 校准结果写回 `importance`,并在 metadata 中记录 `base_importance`、`importance_evaluator` 和 `importance_source`。同时会记录拟人化维度:`persona_importance`、`relationship_weight`、`emotional_weight`、`promise_weight`、`open_loop_weight`、`emotional_debt_weight`、`creative_weight`、`preference_weight`、`self_continuity_weight`、`freshness_weight`、`scar_weight`、`last_emotional_touch_at`、`relationship_phase`、`decay_mode`、`mention_policy`、`mentionability_score` 和 `memory_reason`。 -召回会轻微优先这些关系、承诺、未完成、情感债务、情绪伤痕和创作节点,但不会让硬规则压过语义相关性。“继续”“还有呢”“后来呢”这类低语义追问会优先查看 `open_loop` 槽,再走普通语义召回。普通事实会随时间逐渐降权;承诺、冲突/修复/安慰、重要创作节点会进入 `no_decay`、`scar_slow_decay` 或 `creative_milestone` 等慢衰减策略。 +召回会轻微优先这些关系、承诺、未完成、情感债务、情绪伤痕和创作节点,但不会让硬规则压过语义相关性。“继续”“还有呢”“后来呢”这类低语义追问会优先查看 `open_loop` 槽,再走普通语义召回。普通事实会随时间逐渐降权;承诺、冲突/修复/安慰、重要创作节点会进入 +o_decay`、`scar_slow_decay` 或 `creative_milestone` 等慢衰减策略。 注入结构会按拟人化用途分区:`open_loops` 放未完成事项和承诺,`relationship_memory` 放关系线索,`emotional_context` 放情绪脉络,`creative_threads` 放创作连续性,`self_continuity` 放 Bot 自我日程与主动行为,`stable_facts` 放偏好、画像和稳定事实。每条记忆仍保留“可明说/只调语气/不确定”的用法标记。 diff --git a/core/archive_contract.py b/core/archive_contract.py index e97a60a..38d5359 100644 --- a/core/archive_contract.py +++ b/core/archive_contract.py @@ -4,10 +4,11 @@ import re from typing import Any from .models import MemoryRecord, clean_text +from .temporal_context import build_temporal_memory_meta ARCHIVE_API_VERSION = "1.0" SOURCE_NAME = "memory_companion" -SOURCE_VERSION = "1.6.2-ops.1" +SOURCE_VERSION = "1.6.2-ops.2" _SECRET_PATTERNS = ( (re.compile(r"(?i)\b(password|passwd|pwd)\s*[:=]\s*[^\s,;]+"), r"\1=[REDACTED_SECRET]"), @@ -68,6 +69,7 @@ def archive_payload(record: MemoryRecord, score: float | None = None, reason: st "occurred_at": record.occurred_at, "created_at": record.created_at, "updated_at": record.updated_at, + "temporal": build_temporal_memory_meta(record), "score": score, "topics": [clean_text(item, 80) for item in topics if clean_text(item, 80)][:8], "source_plugin": record.source_plugin or SOURCE_NAME, diff --git a/core/bridge.py b/core/bridge.py index 8b6c751..fcd0160 100644 --- a/core/bridge.py +++ b/core/bridge.py @@ -6,6 +6,7 @@ from zoneinfo import ZoneInfo from .models import EntityRef, MemoryRecord, SessionContext, clean_text from .ops_domain import OpsDomainContract, normalize_ops_audit, normalize_ops_event, normalize_ops_task +from .temporal_context import build_reply_delay, build_temporal_memory_meta LOCAL_TZ = ZoneInfo("Asia/Shanghai") @@ -327,6 +328,23 @@ class MemoryCompanionBridge: companion_bot_energy=companion_bot_energy, ) + def get_reply_delay( + self, + previous_bot_message_at: str, + current_user_reply_at: str, + *, + scope: str = "private", + bot_message_was_open_loop: bool = False, + timezone_name: str = "Asia/Shanghai", + ) -> dict[str, Any]: + return self._plugin.bridge_get_reply_delay( + previous_bot_message_at, + current_user_reply_at, + scope=scope, + bot_message_was_open_loop=bot_message_was_open_loop, + timezone_name=timezone_name, + ) + async def compose_context( self, *, @@ -539,6 +557,7 @@ def serialize_memory(record: MemoryRecord, score: float | None = None, reason: s "updated_at_local": _local_time_label(record.updated_at), "occurred_at": record.occurred_at, "occurred_at_local": _local_time_label(record.occurred_at), + "temporal": build_temporal_memory_meta(record), "time_range": { "start_at": clean_text(metadata.get("start_at"), 80), "end_at": clean_text(metadata.get("end_at"), 80), @@ -564,5 +583,3 @@ def serialize_memory(record: MemoryRecord, score: float | None = None, reason: s if reason: data["reason"] = reason return data - - diff --git a/core/injection.py b/core/injection.py index 99be507..58207dd 100644 --- a/core/injection.py +++ b/core/injection.py @@ -1,4 +1,4 @@ -from __future__ import annotations +from __future__ import annotations import html import json @@ -6,6 +6,7 @@ import re from typing import Any from .models import SearchResult, SessionContext, clean_text +from .temporal_context import build_temporal_memory_meta MEMORY_COMPANION_INJECTION_HEADER = "" MEMORY_COMPANION_INJECTION_FOOTER = "" @@ -22,6 +23,7 @@ class InjectionComposer: slot_sections: list[tuple[str, list[SearchResult]]] | None = None, compact_memory: bool = False, time_context: str = "", + now: Any = None, emotional_tone: str = "neutral", intimacy_level: float = 0.0, companion_bot_mood: str = "", @@ -40,7 +42,7 @@ class InjectionComposer: 120, limit - len(MEMORY_COMPANION_INJECTION_HEADER) - len(MEMORY_COMPANION_INJECTION_FOOTER) - 2, ) - compact_for_budget = compact_memory or len(results) > 2 or limit <= 2200 + compact_for_budget = compact_memory or len(results) > 2 or (limit <= 2200 and not time_context) atmosphere_hint = self._atmosphere_hint(emotional_tone, intimacy_level, companion_bot_mood, companion_bot_energy, time_of_day=time_of_day) rest_check_hint = self._short_rest_check_hint(ctx.message_text, time_of_day, companion_bot_mood) cross_window_rules = ( @@ -123,6 +125,7 @@ class InjectionComposer: closing_lines=closing_lines, inner_limit=inner_limit, short_rest_check=bool(rest_check_hint), + now=now, ) if memory_lines: lines.extend(memory_lines) @@ -172,6 +175,7 @@ class InjectionComposer: closing_lines: list[str], inner_limit: int, short_rest_check: bool = False, + now: Any = None, ) -> list[str]: if short_rest_check: return self._build_short_rest_memory_lines( @@ -179,6 +183,7 @@ class InjectionComposer: base_lines=base_lines, closing_lines=closing_lines, inner_limit=inner_limit, + now=now, ) grouped = { "open_loops": [], @@ -250,6 +255,7 @@ class InjectionComposer: slot_name=slot_name, compact=compact, detail_limit=item_limit, + now=now, ) if fits([*memory_lines, *opening, *item_lines, candidate_line, f""]): line = candidate_line @@ -267,6 +273,7 @@ class InjectionComposer: base_lines: list[str], closing_lines: list[str], inner_limit: int, + now: Any = None, ) -> list[str]: if not results: return [] @@ -290,6 +297,7 @@ class InjectionComposer: slot_name: str, compact: bool = False, detail_limit: int | None = None, + now: Any = None, ) -> str: memory = item.memory metadata = self._metadata_dict(memory) @@ -322,12 +330,30 @@ class InjectionComposer: detail = self._safe_text(detail, content_limit + (120 if not compact else 0)) time_label = self._safe_text(self._time_label(memory), 24) source_label = self._safe_text(self._source_label(memory), 100) + temporal = build_temporal_memory_meta(memory, now) usage = self._expression_usage(item) if not compact else f"表达:{self._expression_label(item)}" - parts = [ - f"内容:{detail}", - f"时间:{time_label}", - f"来源:{source_label}", - ] + parts = [f"内容:{detail}"] + if compact: + parts.extend([ + f"发生:{self._safe_text(temporal.get('relative_label') or time_label, 24)}", + f"距今:{self._safe_text(temporal.get('age_label'), 24)}({self._safe_text(temporal.get('age_display'), 32)})", + f"跨日:{'是' if temporal.get('crossed_date') else '否'}", + f"状态:{'不能代表当前实时事实' if temporal.get('stale') else '历史背景' if temporal.get('age_label') not in {'just_now', 'recent', 'same_day'} else '近期参考'}", + f"来源:{source_label}", + ]) + else: + parts.extend([ + f"发生时间:{self._safe_text(temporal.get('event_at_local') or time_label, 32)}", + f"入库时间:{self._safe_text(temporal.get('ingested_at'), 32)}", + f"当前提取时间:{self._safe_text(temporal.get('retrieved_at'), 32)}", + f"距今:{self._safe_text(temporal.get('age_display'), 32)}", + f"时间状态:{self._safe_text(temporal.get('relative_label') or temporal.get('age_label'), 24)}", + f"跨日:{'是' if temporal.get('crossed_date') else '否'}", + f"当前有效性:{'不能代表当前实时事实' if temporal.get('stale') else '可作为当前相关背景,但不替代最新状态' if temporal.get('age_label') not in {'just_now', 'recent', 'same_day'} else '可作为近期参考'}", + f"时间来源:{self._safe_text(temporal.get('time_source'), 32)}", + f"时间精度:{self._safe_text(temporal.get('time_precision'), 16)}", + f"来源:{source_label}", + ]) if compact: parts.extend( [ diff --git a/core/models.py b/core/models.py index 1abd397..e29f72d 100644 --- a/core/models.py +++ b/core/models.py @@ -1,4 +1,4 @@ -from __future__ import annotations +from __future__ import annotations import json import re @@ -128,6 +128,7 @@ class MemoryRecord: def ensure_defaults(self) -> "MemoryRecord": now = utc_now() + occurred_was_missing = not bool(self.occurred_at) if not self.id: self.id = new_id("mem") if not self.created_at: @@ -136,6 +137,13 @@ class MemoryRecord: self.updated_at = self.created_at if not self.occurred_at: self.occurred_at = self.created_at + if not isinstance(self.metadata, dict): + self.metadata = {} + self.metadata.setdefault("ingested_at", self.created_at) + self.metadata.setdefault("timezone", "Asia/Shanghai") + self.metadata.setdefault("occurred_at_estimated", occurred_was_missing) + self.metadata.setdefault("time_source", "ingestion_time" if occurred_was_missing else "unknown") + self.metadata.setdefault("time_precision", "unknown" if occurred_was_missing else "minute") self.content = clean_text(self.content, 4000) self.evidence = clean_text(self.evidence, 4000) self.confidence = clamp_float(self.confidence, default=0.5) diff --git a/core/service.py b/core/service.py index 4c93bc3..d358184 100644 --- a/core/service.py +++ b/core/service.py @@ -1,4 +1,4 @@ -from __future__ import annotations +from __future__ import annotations import asyncio import time @@ -24,6 +24,7 @@ from .astrbot_compat import ( sanitize_request_history, ) from .bridge import serialize_memory +from .temporal_context import build_reply_delay from .chat_import import HistoricalChatImporter from .classifier import MemoryClassifier from .config import ConfigView @@ -601,6 +602,10 @@ class MemoryCompanionService: event_metadata = dict(metadata or {}) if source: event_metadata.setdefault("source", clean_text(source, 80)) + event_metadata.setdefault("timezone", clean_text(event_metadata.get("timezone"), 80) or "Asia/Shanghai") + event_metadata.setdefault("time_source", "event_timestamp" if occurred_at else "ingestion_time") + event_metadata.setdefault("time_precision", "second" if occurred_at and str(occurred_at).count(":") >= 2 else "minute" if occurred_at else "unknown") + event_metadata.setdefault("occurred_at_estimated", not bool(occurred_at)) if event_type == "bot_response": event_metadata.setdefault("owner_bot_id", subject_id) if user_name: @@ -901,6 +906,23 @@ class MemoryCompanionService: "items": items, } + def bridge_get_reply_delay( + self, + previous_bot_message_at: str, + current_user_reply_at: str, + *, + scope: str = "private", + bot_message_was_open_loop: bool = False, + timezone_name: str = "Asia/Shanghai", + ) -> dict[str, Any]: + return build_reply_delay( + previous_bot_message_at, + current_user_reply_at, + scope=scope, + bot_message_was_open_loop=bot_message_was_open_loop, + timezone_name=timezone_name, + ) + async def bridge_compose_injection( self, query: str, @@ -4342,7 +4364,7 @@ class MemoryCompanionService: injection_max_chars, intent_context=intent_context, slot_sections=self._slot_sections(slot_map), - compact_memory=bool(short_reply_anchor) or time_intent.active or self._message_requests_temporal_aggregate(ctx.message_text or intent.query), + compact_memory=bool(short_reply_anchor) or self._message_requests_temporal_aggregate(ctx.message_text or intent.query), time_context=time_intent.display_range if time_intent.active else "", emotional_tone=getattr(turn_signal, "emotional_tone", "neutral"), intimacy_level=getattr(turn_signal, "intimacy_level", 0.0), @@ -4628,7 +4650,7 @@ class MemoryCompanionService: injection_max_chars, intent_context=intent_context, slot_sections=self._slot_sections(slot_map), - compact_memory=bool(short_reply_anchor) or time_intent.active or self._message_requests_temporal_aggregate(ctx.message_text or intent.query), + compact_memory=bool(short_reply_anchor) or self._message_requests_temporal_aggregate(ctx.message_text or intent.query), time_context=time_intent.display_range if time_intent.active else "", emotional_tone=getattr(turn_signal, "emotional_tone", "neutral"), intimacy_level=getattr(turn_signal, "intimacy_level", 0.0), diff --git a/core/temporal_context.py b/core/temporal_context.py new file mode 100644 index 0000000..d161306 --- /dev/null +++ b/core/temporal_context.py @@ -0,0 +1,229 @@ +from __future__ import annotations + +from datetime import datetime +from typing import Any +from zoneinfo import ZoneInfo + +from .models import clean_text + +DEFAULT_TIMEZONE = "Asia/Shanghai" +LOCAL_TZ = ZoneInfo(DEFAULT_TIMEZONE) +AGE_LABELS = { + "just_now": "刚刚", "recent": "不久前", "same_day": "今天稍早", "overnight": "昨晚", + "previous_day": "昨天", "few_days": "前几天", "older": "之前", "historical": "较早以前", "unknown": "时间不明", +} +EXPIRY_DEFAULTS = { + "weather_sensitive": 6 * 60 * 60, "body_state": 6 * 60 * 60, "emotion_state": 6 * 60 * 60, + "transit_state": 6 * 60 * 60, "waiting_state": 6 * 60 * 60, "service_status": 24 * 60 * 60, + "backup_status": 24 * 60 * 60, "operation_state": 24 * 60 * 60, "temporary_plan": 24 * 60 * 60, +} +LONG_TERM_TYPES = { + "user_preference", "user_habit", "user_profile", "stable_fact", "creative_project", "creative_progress", + "archive_summary", "conversation_summary", "companion_note", "persona_life", "self_timeline", +} + + +def _parse_datetime(value: Any, *, timezone_name: str = DEFAULT_TIMEZONE) -> datetime | None: + text = clean_text(value, 120) + if not text: + return None + try: + parsed = datetime.fromisoformat(text.replace("Z", "+00:00")) + except (TypeError, ValueError, OverflowError): + return None + if parsed.tzinfo is None: + try: + parsed = parsed.replace(tzinfo=ZoneInfo(timezone_name or DEFAULT_TIMEZONE)) + except Exception: + parsed = parsed.replace(tzinfo=LOCAL_TZ) + return parsed + + +def _as_local(value: datetime, timezone_name: str = DEFAULT_TIMEZONE) -> datetime: + try: + return value.astimezone(ZoneInfo(timezone_name or DEFAULT_TIMEZONE)) + except Exception: + return value.astimezone(LOCAL_TZ) + + +def _now_datetime(now: Any = None, *, timezone_name: str = DEFAULT_TIMEZONE) -> datetime: + if isinstance(now, datetime): + return now if now.tzinfo else now.replace(tzinfo=LOCAL_TZ) + parsed = _parse_datetime(now, timezone_name=timezone_name) if now is not None else None + return parsed or datetime.now(ZoneInfo("UTC")) + + +def _infer_precision(value: Any) -> str: + text = clean_text(value, 120) + if not text: + return "unknown" + if "T" in text or " " in text: + return "second" if text.count(":") >= 2 else "minute" if ":" in text else "hour" + return "date" + + +def _topic_expiry(record: Any, metadata: dict[str, Any]) -> tuple[str, int | None]: + topic_expiry = clean_text(metadata.get("topic_expiry"), 80).lower() + if topic_expiry: + try: + ttl = int(metadata["stale_after_seconds"]) if metadata.get("stale_after_seconds") is not None else EXPIRY_DEFAULTS.get(topic_expiry) + except (TypeError, ValueError): + ttl = EXPIRY_DEFAULTS.get(topic_expiry) + return topic_expiry, max(0, ttl) if ttl is not None else None + memory_type = clean_text(getattr(record, "memory_type", ""), 80).lower() + tags = {clean_text(tag, 80).lower() for tag in (getattr(record, "tags", []) or [])} + content = clean_text(getattr(record, "content", ""), 800).lower() + if any(term in content for term in ("天气", "下雨", "下雪", "气温", "weather")) or "weather" in tags: + return "weather_sensitive", EXPIRY_DEFAULTS["weather_sensitive"] + if memory_type in LONG_TERM_TYPES or clean_text(getattr(record, "lifecycle", ""), 60).lower() == "stable_memory": + return "long_term", None + if any(term in content for term in ("服务状态", "备份", "部署", "故障", "运行中", "健康检查")): + return "service_status", EXPIRY_DEFAULTS["service_status"] + return "general", None + + +def _event_and_ingestion(record: Any, metadata: dict[str, Any], timezone_name: str) -> tuple[datetime | None, datetime | None, bool, str, str]: + occurred_value = clean_text(getattr(record, "occurred_at", ""), 120) + created_value = clean_text(getattr(record, "created_at", ""), 120) + event_at = _parse_datetime(occurred_value, timezone_name=timezone_name) + ingested_at = _parse_datetime(metadata.get("ingested_at") or created_value, timezone_name=timezone_name) + estimated = False + if event_at is None: + event_at = ingested_at + estimated = bool(event_at) + elif metadata.get("occurred_at_estimated") is not None: + estimated = bool(metadata.get("occurred_at_estimated")) + source = clean_text(metadata.get("time_source"), 80).lower() or ("ingestion_time" if estimated else "unknown") + precision = clean_text(metadata.get("time_precision"), 20).lower() or _infer_precision(occurred_value or created_value) + if estimated and not metadata.get("time_precision"): + precision = "unknown" + return event_at, ingested_at, estimated, source, precision + + +def classify_memory_age(event_at: Any, now: Any = None, *, timezone_name: str = DEFAULT_TIMEZONE) -> str: + event = _parse_datetime(event_at, timezone_name=timezone_name) + if event is None: + return "unknown" + current = _now_datetime(now, timezone_name=timezone_name) + seconds = (current - event).total_seconds() + if seconds <= 2 * 60: + return "just_now" + if seconds <= 30 * 60: + return "recent" + event_local = _as_local(event, timezone_name) + current_local = _as_local(current, timezone_name) + crossed_date = event_local.date() != current_local.date() + if crossed_date and seconds <= 36 * 60 * 60: + return "overnight" + if seconds < 12 * 60 * 60 and not crossed_date: + return "same_day" + if seconds <= 2 * 24 * 60 * 60: + return "previous_day" + if seconds <= 7 * 24 * 60 * 60: + return "few_days" + if seconds <= 30 * 24 * 60 * 60: + return "older" + return "historical" + + +def resolve_relative_time_label(event_at: Any, now: Any = None, *, timezone_name: str = DEFAULT_TIMEZONE) -> str: + event = _parse_datetime(event_at, timezone_name=timezone_name) + if event is None: + return AGE_LABELS["unknown"] + current = _now_datetime(now, timezone_name=timezone_name) + label = classify_memory_age(event, current, timezone_name=timezone_name) + if label == "overnight": + hour = _as_local(event, timezone_name).hour + return "昨晚" if hour >= 18 or hour < 5 else "隔夜" + return AGE_LABELS[label] + + +def _age_display(seconds: int | None) -> str: + if seconds is None: + return "时间不明" + if seconds < 60: + return f"约 {max(0, seconds)} 秒" + minutes = seconds // 60 + if minutes < 60: + return f"约 {minutes} 分钟" + hours = minutes // 60 + if hours < 48: + return f"约 {hours} 小时" + return f"约 {hours // 24} 天" + + +def is_memory_stale(record: Any, now: Any = None, *, timezone_name: str = DEFAULT_TIMEZONE) -> tuple[bool, str]: + metadata = getattr(record, "metadata", {}) + metadata = metadata if isinstance(metadata, dict) else {} + event_at, _, _, _, _ = _event_and_ingestion(record, metadata, timezone_name) + topic_expiry, ttl = _topic_expiry(record, metadata) + if ttl is None or event_at is None: + return False, "" + age_seconds = (_now_datetime(now, timezone_name=timezone_name) - event_at).total_seconds() + return (True, f"{topic_expiry}_ttl_exceeded") if age_seconds > ttl else (False, "") + + +def build_temporal_memory_meta(record: Any, now: Any = None) -> dict[str, Any]: + metadata = getattr(record, "metadata", {}) + metadata = metadata if isinstance(metadata, dict) else {} + timezone_name = clean_text(metadata.get("timezone"), 80) or DEFAULT_TIMEZONE + event_at, ingested_at, estimated, source, precision = _event_and_ingestion(record, metadata, timezone_name) + current = _now_datetime(now, timezone_name=timezone_name) + event_local = _as_local(event_at, timezone_name) if event_at else None + current_local = _as_local(current, timezone_name) + age_seconds = None if event_at is None else max(0, int((current - event_at).total_seconds())) + topic_expiry, ttl = _topic_expiry(record, metadata) + stale, stale_reason = is_memory_stale(record, current, timezone_name=timezone_name) + crossed_date = bool(event_local and event_local.date() != current_local.date()) + return { + "event_at": event_at.isoformat(timespec="seconds") if event_at else "", + "event_at_local": event_local.strftime("%Y-%m-%d %H:%M") if event_local else "", + "ingested_at": ingested_at.isoformat(timespec="seconds") if ingested_at else "", + "retrieved_at": current.isoformat(timespec="seconds"), + "age_seconds": age_seconds, + "age_minutes": None if age_seconds is None else age_seconds // 60, + "age_label": classify_memory_age(event_at, current, timezone_name=timezone_name), + "relative_label": resolve_relative_time_label(event_at, current, timezone_name=timezone_name), + "age_display": _age_display(age_seconds), + "crossed_date": crossed_date, + "stale": stale, + "stale_reason": stale_reason, + "time_source": source or "unknown", + "time_precision": precision or "unknown", + "timezone": timezone_name, + "occurred_at_estimated": estimated, + "topic_expiry": topic_expiry, + "stale_after_seconds": ttl, + } + + +def build_reply_delay(previous_bot_message_at: Any, current_user_reply_at: Any, *, scope: str = "private", bot_message_was_open_loop: bool = False, timezone_name: str = DEFAULT_TIMEZONE) -> dict[str, Any]: + previous = _parse_datetime(previous_bot_message_at, timezone_name=timezone_name) + current = _parse_datetime(current_user_reply_at, timezone_name=timezone_name) + valid = previous is not None and current is not None and current >= previous + if not valid: + return { + "has_previous_bot_message": False, "previous_bot_message_at": previous.isoformat(timespec="seconds") if previous else "", + "current_user_reply_at": current.isoformat(timespec="seconds") if current else "", "delay_seconds": None, "delay_minutes": None, + "delay_label": "unknown", "crossed_date": False, "bot_message_was_open_loop": bool(bot_message_was_open_loop), + "should_acknowledge_delay": False, "scope": clean_text(scope, 40) or "unknown", + } + delay_seconds = int((current - previous).total_seconds()) + delay_label = classify_memory_age(previous, current, timezone_name=timezone_name) + crossed_date = _as_local(previous, timezone_name).date() != _as_local(current, timezone_name).date() + private_or_unknown = clean_text(scope, 40).lower() != "group" + return { + "has_previous_bot_message": True, "previous_bot_message_at": previous.isoformat(timespec="seconds"), + "current_user_reply_at": current.isoformat(timespec="seconds"), "delay_seconds": delay_seconds, + "delay_minutes": delay_seconds // 60, "delay_label": delay_label, "crossed_date": crossed_date, + "bot_message_was_open_loop": bool(bot_message_was_open_loop), + "should_acknowledge_delay": bool(bot_message_was_open_loop and private_or_unknown and delay_label in {"overnight", "previous_day", "few_days", "older", "historical"}), + "scope": clean_text(scope, 40) or "unknown", + } + + +def temporal_scope_key(*, scope: str, session_id: str = "", user_id: str = "", group_id: str = "") -> tuple[str, str, str, str]: + normalized_scope = clean_text(scope, 40).lower() or "unknown" + if normalized_scope == "group": + return normalized_scope, clean_text(session_id, 200), "", clean_text(group_id, 120) + return normalized_scope, clean_text(session_id, 200), clean_text(user_id, 120), "" diff --git a/docs/时间感知兼容说明.md b/docs/时间感知兼容说明.md new file mode 100644 index 0000000..514fd9c --- /dev/null +++ b/docs/时间感知兼容说明.md @@ -0,0 +1,43 @@ +# 时间感知兼容说明 + +> Q4:记忆插件时间感知改造;数据库结构不变。 + +## 统一合同 + +记忆记录继续保留 `occurred_at`、`created_at`、`updated_at` 和 `last_accessed_at` 四个独立字段。`core/temporal_context.py` 在检索、注入、Bridge 和 Archivist 序列化时动态生成 `temporal`,不会把 `age_seconds` 或 `age_minutes` 写回数据库。 + +记录 metadata 会补齐以下来源信息: + +- `time_source`:事件时间来源;未知时为 `unknown`,无可靠事件时间时为 `ingestion_time`。 +- `time_precision`:`second`、`minute`、`hour`、`date` 或 `unknown`。 +- `timezone`:默认 `Asia/Shanghai`,调用方可覆盖。 +- `ingested_at`:进入记忆库的时间。 +- `occurred_at_estimated`:无法确认事件时间时为 `true`。 + +## 平台来源矩阵 + +| 平台/入口 | 首选时间值 | `time_source` | 估算规则 | +| --- | --- | --- | --- | +| QQ Official | AstrBot 事件或消息对象携带的消息时间 | `event_timestamp` 或 `message_timestamp` | 没有事件时间时回退 `ingestion_time`,并标记估算 | +| OneBot/QQ | OneBot/AstrBot 消息事件时间 | `event_timestamp` 或 `message_timestamp` | 不使用 `last_accessed_at`;缺失时估算 | +| Telegram | 适配器传入的消息时间 | `message_timestamp` | 外部转发只有观察时间时使用 `controller_observed_at` | +| 历史导入 | 导入记录原始时间 | `imported_record` | 原始记录无时间时使用 `ingestion_time` | +| 外部 Controller | Controller 返回的观察/发生时间 | `controller_observed_at` | 只有观察时间时不得伪装成事件实际发生时间 | + +调用方应把上述字段放入 `MemoryRecord.metadata` 或 `record_external_event()` 的 metadata;时间值本身仍放入 `occurred_at`,入库时间由 `created_at`/`ingested_at` 表示。 + +## 注入与 Bridge + +- 普通注入带紧凑的“发生、距今、跨日、状态”信息。 +- 时间敏感查询带发生时间、入库时间、当前提取时间、年龄、跨日、有效性、来源和精度。 +- `serialize_memory()`、`archive_payload()` 和 Archivist 检索结果都包含 `temporal`。 +- `bridge_get_reply_delay()` 返回隔夜等延迟标签;私聊可建议提及,群聊默认关闭私密等待情绪。 +- 运维状态仍以 NAS Ops/Controller 当前事实为准,旧记忆只能作为历史背景。 + +## 数据库结论 + +无需迁移。现有 metadata 已是 JSON 字段,新增来源字段使用向后兼容的默认值;动态年龄只在读取出口计算,不新增表列,也不改变历史记录主键或索引。 + +## 降级行为 + +时间值为空、格式错误或时区不可用时,计算层返回 `age_label=unknown`、`time_source=unknown` 或 `ingestion_time`,Bridge/注入继续返回正常结果,不阻断聊天。 diff --git a/docs/错题本.md b/docs/错题本.md index 5971fc6..d64c1f7 100644 --- a/docs/错题本.md +++ b/docs/错题本.md @@ -1,4 +1,4 @@ -# 错题本 +# 错题本 ## 2026-07-22 — 测试仍引用插件旧包名 @@ -172,3 +172,12 @@ - 修复或规避:在宿主加载完成 Hook 中重新调用 `resolve_memory_source`;同时优先复用当前进程已加载的 ops 模块,避免重复导入造成空 Bridge。 - 预防规则:跨插件发现不能只测试“模块能否 import”;必须验证插件生命周期顺序、Bridge 实例是否已初始化和实机 capability 返回。 - 验证证据:VM 日志 `source=memory_companion version=1.6.2-ops.1 available=True search=True`;AstrBot `4.26.6`、`NRestarts=0`。 +## 2026-07-24 — Q4 动态时间元数据不能落库 + +- 阶段:Q4 时间感知改造 +- 类型:编码 / 测试 / API契约 / 部署 +- 现象:已有 `occurred_at`、`created_at` 等字段,但注入和 Bridge 只能给出裸时间,模型容易把历史天气、备份或服务状态误当作当前事实。 +- 根因:时间跨度、跨日、事实有效期和时间来源没有统一合同;如果把“距今多久”持久化,下一次读取就会过期。 +- 修复或规避:新增 `core/temporal_context.py`,在检索/注入/Bridge/Archivist 出口动态生成 `temporal`;metadata 只补来源、时区、精度和估算标记;增加 `bridge_get_reply_delay()`,群聊默认不产生私密等待情绪。 +- 预防规则:不得用 `last_accessed_at` 代替事件时间;不得把 `age_seconds` 写入数据库;运维当前状态必须重新取 Controller 事实,旧记忆只作历史背景。 +- 验证证据:时间合同测试 13 项通过;非宿主依赖的 unittest 130 项通过;`compileall` 通过;数据库无需迁移,版本升至 `1.6.2-ops.2`。 \ No newline at end of file diff --git a/metadata.yaml b/metadata.yaml index 62e38e6..d5a8c8f 100644 --- a/metadata.yaml +++ b/metadata.yaml @@ -1,8 +1,8 @@ -name: astrbot_plugin_memory_companion_ops +name: astrbot_plugin_memory_companion_ops display_name: 我会牢牢记住你・运维记忆 author: menglimi author_url: https://github.com/menglimi -version: 1.6.2-ops.1 +version: 1.6.2-ops.2 description: 我会牢牢记住你・运维记忆是面向专用 AstrBot VM 运维平台的记忆与项目连续性中枢。它统一管理长期记忆、历史对话整理、群聊连续对话记忆、主链注入、权限边界、知识图谱、陪伴插件桥接、自然衰减、可移植数据和运行诊断。 desc: 为 AstrBot 提供主链记忆注入、历史聊天整理导入、连续对话记忆、陪伴插件协同、主动记忆/回忆工具、知识图谱、权限边界、自我时间线、自然衰减、迁移导出和成本诊断。 repo: https://forgejo.yokiirobw.top:55443/YokiiroBW/astrbot_plugin_memory_companion_ops diff --git a/plugin_identity.py b/plugin_identity.py index c1a89e6..4dd1e75 100644 --- a/plugin_identity.py +++ b/plugin_identity.py @@ -1,8 +1,8 @@ -from __future__ import annotations +from __future__ import annotations PLUGIN_NAME = "astrbot_plugin_memory_companion_ops" PLUGIN_DISPLAY_NAME = "我会牢牢记住你・运维记忆" -PLUGIN_VERSION = "1.6.2-ops.1" +PLUGIN_VERSION = "1.6.2-ops.2" PLUGIN_REPO = "https://forgejo.yokiirobw.top:55443/YokiiroBW/astrbot_plugin_memory_companion_ops" PRIVATE_COMPANION_PLUGIN_NAMES = ( "astrbot_plugin_private_companion_ops", diff --git a/tests/test_archive_contract.py b/tests/test_archive_contract.py index be7be6d..92dcd49 100644 --- a/tests/test_archive_contract.py +++ b/tests/test_archive_contract.py @@ -1,4 +1,4 @@ -from core.archive_contract import archive_capabilities, archive_payload, redact_text +from core.archive_contract import archive_capabilities, archive_payload, redact_text from core.models import EntityRef, MemoryRecord, SessionContext from core.visibility import VisibilityPolicy @@ -6,7 +6,7 @@ from core.visibility import VisibilityPolicy def test_archive_capabilities_use_stable_contract(): payload = archive_capabilities() assert payload["source_name"] == "memory_companion" - assert payload["source_version"] == "1.6.2-ops.1" + assert payload["source_version"] == "1.6.2-ops.2" assert payload["archive_api_version"] == "1.0" assert payload["memory_write_available"] is False assert payload["available"] is True diff --git a/tests/test_temporal_context.py b/tests/test_temporal_context.py new file mode 100644 index 0000000..265ef76 --- /dev/null +++ b/tests/test_temporal_context.py @@ -0,0 +1,145 @@ +from datetime import datetime + +from core.archive_contract import archive_payload +from core.bridge import serialize_memory +from core.injection import InjectionComposer +from core.models import EntityRef, MemoryRecord, SearchResult, SessionContext +from core.temporal_context import ( + build_reply_delay, + build_temporal_memory_meta, + classify_memory_age, + is_memory_stale, + resolve_relative_time_label, + temporal_scope_key, +) + + +NOW = "2026-07-24T08:00:00+08:00" + + +def make_record(**kwargs): + defaults = { + "id": "m1", + "scope": "private", + "session_id": "qq:private:u1", + "content": "昨晚下的雨好大", + "created_at": "2026-07-23T21:00:03+08:00", + "occurred_at": "2026-07-23T21:00:00+08:00", + "metadata": {"time_source": "message_timestamp", "time_precision": "minute", "timezone": "Asia/Shanghai"}, + } + defaults.update(kwargs) + return MemoryRecord(**defaults) + + +def test_event_time_and_ingestion_time_are_distinct(): + meta = build_temporal_memory_meta(make_record(), NOW) + assert meta["event_at"] == "2026-07-23T21:00:00+08:00" + assert meta["ingested_at"] == "2026-07-23T21:00:03+08:00" + assert meta["occurred_at_estimated"] is False + + +def test_missing_event_time_falls_back_to_ingestion_and_is_estimated(): + record = make_record(occurred_at="", metadata={}) + meta = build_temporal_memory_meta(record, NOW) + assert meta["event_at"] == meta["ingested_at"] + assert meta["occurred_at_estimated"] is True + assert meta["time_source"] == "ingestion_time" + assert meta["time_precision"] == "unknown" + + +def test_age_labels_cover_just_now_overnight_and_older_ranges(): + assert classify_memory_age("2026-07-24T07:59:00+08:00", NOW) == "just_now" + assert classify_memory_age("2026-07-23T21:00:00+08:00", NOW) == "overnight" + assert classify_memory_age("2026-07-22T08:00:00+08:00", NOW) == "previous_day" + assert classify_memory_age("2026-07-19T08:00:00+08:00", NOW) == "few_days" + + +def test_relative_label_and_crossed_date_match_overnight_scenario(): + meta = build_temporal_memory_meta(make_record(), NOW) + assert meta["relative_label"] == "昨晚" + assert meta["age_seconds"] == 39600 + assert meta["crossed_date"] is True + assert meta["age_display"] == "约 11 小时" + + +def test_weather_memory_expires_but_long_term_preference_does_not(): + weather = make_record(metadata={"topic_expiry": "weather_sensitive"}) + assert is_memory_stale(weather, "2026-07-24T04:01:00+08:00")[0] is True + preference = make_record(memory_type="user_preference", content="喜欢蓝风铃", metadata={}) + assert is_memory_stale(preference, "2027-07-24T08:00:00+08:00") == (False, "") + + +def test_dynamic_age_changes_without_mutating_record_metadata(): + record = make_record() + first = build_temporal_memory_meta(record, "2026-07-24T08:00:00+08:00") + second = build_temporal_memory_meta(record, "2026-07-24T09:00:00+08:00") + assert second["age_seconds"] == first["age_seconds"] + 3600 + assert "age_seconds" not in record.metadata + + +def test_timezone_conversion_is_correct(): + record = make_record( + occurred_at="2026-07-23T13:00:00+00:00", + created_at="2026-07-23T13:00:03+00:00", + metadata={"timezone": "Asia/Shanghai", "time_source": "telegram", "time_precision": "minute"}, + ) + meta = build_temporal_memory_meta(record, "2026-07-24T08:00:00+08:00") + assert meta["event_at_local"] == "2026-07-23 21:00" + assert meta["time_source"] == "telegram" + + +def test_unknown_time_is_safe(): + record = make_record(occurred_at="not-a-date", created_at="", metadata={}) + meta = build_temporal_memory_meta(record, NOW) + assert meta["age_label"] == "unknown" + assert meta["stale"] is False + + +def test_bridge_and_archive_payloads_include_temporal_contract(): + record = make_record() + assert "temporal" in serialize_memory(record) + payload = archive_payload(record) + assert payload["temporal"]["event_at"] + assert payload["temporal"]["time_source"] == "message_timestamp" + assert payload["temporal"]["time_precision"] == "minute" + + +def test_injection_has_detailed_temporal_state_for_time_sensitive_context(): + record = make_record() + result = SearchResult(memory=record, score=0.9, reason="temporal") + text = InjectionComposer().compose( + SessionContext(session_id="qq:private:u1", scope="private", user_id="u1", message_text="昨晚后来还好吗?"), + [result], + max_chars=3600, + time_context="昨晚", + now=NOW, + ) + assert "发生时间:2026-07-23 21:00" in text + assert "距今:约 11 小时" in text + assert "时间状态:昨晚" in text + assert "跨日:是" in text + + +def test_reply_delay_supports_private_overnight_but_not_group_pressure(): + private = build_reply_delay( + "2026-07-23T21:00:00+08:00", NOW, scope="private", bot_message_was_open_loop=True, + ) + group = build_reply_delay( + "2026-07-23T21:00:00+08:00", NOW, scope="group", bot_message_was_open_loop=True, + ) + assert private["delay_label"] == "overnight" + assert private["should_acknowledge_delay"] is True + assert group["delay_label"] == "overnight" + assert group["should_acknowledge_delay"] is False + + +def test_private_and_group_temporal_scope_keys_do_not_cross(): + assert temporal_scope_key(scope="private", session_id="s1", user_id="u1", group_id="g1") == ("private", "s1", "u1", "") + assert temporal_scope_key(scope="group", session_id="s1", user_id="u1", group_id="g1") == ("group", "s1", "", "g1") + + +def test_daylight_saving_or_offset_input_does_not_raise(): + assert resolve_relative_time_label(datetime.fromisoformat("2026-07-23T13:00:00+00:00"), NOW) == "昨晚" + + +