deeptutor-memory 1.7.0__py3-none-any.whl

deeptutor/services/memory/ids.py

@@ -0,0 +1,80 @@
+"""Stable, time-ordered identifiers for trace events and document entries.
+
+Format: 26-character Crockford-base32 (ULID-style).
+
+- Trace ids:  ``<surface>:<ULID>`` — e.g. ``chat:01HZK4ABCDEFGHJKMNPQRSTVWX``
+- Entry ids:  ``m_<ULID>``        — used in MD footnote labels
+
+The ULID's leading 10 characters encode a millisecond timestamp, giving
+natural chronological sort across files and within a file.
+"""
+
+from __future__ import annotations
+
+import re
+import secrets
+import time
+
+_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"  # Crockford
+_ULID_TS_LEN = 10
+_ULID_RAND_LEN = 16
+_ULID_LEN = _ULID_TS_LEN + _ULID_RAND_LEN
+
+_ENTRY_RE = re.compile(r"^m_[0-9A-HJKMNP-TV-Z]{26}$")
+_TRACE_RE = re.compile(r"^[a-z][a-z0-9_-]*:[0-9A-HJKMNP-TV-Z]{26}$")
+# Snapshot ref points to a current workspace entity. The id portion is
+# whatever the per-surface adapter chose (doc_id / record_id / kb_name /
+# bot name / session_id / "session:question" composites). Permissive
+# enough to allow embedded ``:``; restrictive enough to keep refs safe
+# to embed in the comma-separated footnote serialization.
+_SNAPSHOT_RE = re.compile(r"^[a-z][a-z0-9_-]*:[A-Za-z0-9_.:\-]+$")
+# L3 surface ref — bare surface name like ``chat``, ``notebook``. L3 is
+# a synthesis layer that points at L2 *files*, not L2 entries, so its
+# refs need no id portion. Whitelist (not a loose regex) so a malformed
+# ref like ``not-an-id`` doesn't accidentally validate. Mirrors
+# :data:`paths.SURFACES`; if you add a surface, add it here too.
+_SHORTNAME_REFS = frozenset({"chat", "notebook", "quiz", "kb", "book", "partner", "cowriter"})
+
+
+def _encode(n: int, length: int) -> str:
+    chars: list[str] = []
+    for _ in range(length):
+        chars.append(_BASE32[n & 0x1F])
+        n >>= 5
+    return "".join(reversed(chars))
+
+
+def new_ulid() -> str:
+    ts = int(time.time() * 1000) & ((1 << (_ULID_TS_LEN * 5)) - 1)
+    rand = secrets.randbits(_ULID_RAND_LEN * 5)
+    return _encode(ts, _ULID_TS_LEN) + _encode(rand, _ULID_RAND_LEN)
+
+
+def new_entry_id() -> str:
+    return f"m_{new_ulid()}"
+
+
+def new_trace_id(surface: str) -> str:
+    return f"{surface}:{new_ulid()}"
+
+
+def is_entry_id(s: str) -> bool:
+    return bool(_ENTRY_RE.match(s))
+
+
+def is_trace_id(s: str) -> bool:
+    return bool(_TRACE_RE.match(s))
+
+
+def is_snapshot_ref(s: str) -> bool:
+    return bool(_SNAPSHOT_RE.match(s))
+
+
+def is_shortname_ref(s: str) -> bool:
+    """Bare surface name — the form used by L3 refs (whitelist)."""
+    return s in _SHORTNAME_REFS
+
+
+def is_valid_ref(s: str) -> bool:
+    """Any form of ref the ops validator accepts."""
+    return is_entry_id(s) or is_trace_id(s) or is_snapshot_ref(s) or is_shortname_ref(s)

deeptutor/services/memory/ops.py

@@ -0,0 +1,149 @@
+"""Atomic add/edit/delete operations on memory documents.
+
+A batch of ops is validated as a whole and applied only if all ops pass.
+Conflicting ops (e.g. ``delete`` and ``edit`` on the same id within one
+batch) reject the entire batch — the LLM doesn't get to self-contradict.
+
+Pure functions; no I/O, no LLM.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Union
+
+from deeptutor.services.memory.document import Document, Entry
+from deeptutor.services.memory.ids import is_entry_id, is_valid_ref, new_entry_id
+
+_MAX_TEXT_LEN = 240
+_MAX_SECTION_LEN = 80
+_DELETE_REASONS = frozenset({"contradicted", "superseded", "stale", "low-signal"})
+
+
+@dataclass(frozen=True)
+class AddOp:
+    section: str
+    text: str
+    refs: list[str]
+    op: Literal["add"] = "add"
+
+
+@dataclass(frozen=True)
+class EditOp:
+    target_id: str
+    new_text: str
+    new_refs: list[str]
+    op: Literal["edit"] = "edit"
+
+
+@dataclass(frozen=True)
+class DeleteOp:
+    target_id: str
+    reason: str
+    op: Literal["delete"] = "delete"
+
+
+Op = Union[AddOp, EditOp, DeleteOp]
+
+
+@dataclass
+class OpResult:
+    op: Op
+    status: Literal["applied"]
+    entry_id: str | None = None  # populated for add ops
+    detail: str = ""
+
+
+@dataclass
+class ApplyReport:
+    accepted: bool
+    results: list[OpResult] = field(default_factory=list)
+    reason: str = ""
+
+
+class OpValidationError(Exception):
+    """Raised when a batch fails pre-flight validation."""
+
+
+def _validate(doc: Document, ops: list[Op]) -> None:
+    edits: set[str] = set()
+    deletes: set[str] = set()
+
+    for op in ops:
+        if isinstance(op, AddOp):
+            if not op.text or len(op.text) > _MAX_TEXT_LEN:
+                raise OpValidationError(
+                    f"add: text length must be 1..{_MAX_TEXT_LEN} (got {len(op.text)})"
+                )
+            if not op.section or len(op.section) > _MAX_SECTION_LEN:
+                raise OpValidationError(f"add: invalid section {op.section!r}")
+            if not op.refs:
+                raise OpValidationError("add: refs must be non-empty")
+            for ref in op.refs:
+                if not is_valid_ref(ref):
+                    raise OpValidationError(f"add: malformed ref {ref!r}")
+        elif isinstance(op, EditOp):
+            if not is_entry_id(op.target_id):
+                raise OpValidationError(f"edit: malformed target_id {op.target_id!r}")
+            if doc.find(op.target_id) is None:
+                raise OpValidationError(f"edit: target_id {op.target_id} not found")
+            if not op.new_text or len(op.new_text) > _MAX_TEXT_LEN:
+                raise OpValidationError(
+                    f"edit: text length must be 1..{_MAX_TEXT_LEN} (got {len(op.new_text)})"
+                )
+            if not op.new_refs:
+                raise OpValidationError("edit: refs must be non-empty")
+            for ref in op.new_refs:
+                if not is_valid_ref(ref):
+                    raise OpValidationError(f"edit: malformed ref {ref!r}")
+            if op.target_id in deletes:
+                raise OpValidationError(
+                    f"batch conflict: edit and delete on same id {op.target_id}"
+                )
+            edits.add(op.target_id)
+        elif isinstance(op, DeleteOp):
+            if not is_entry_id(op.target_id):
+                raise OpValidationError(f"delete: malformed target_id {op.target_id!r}")
+            if doc.find(op.target_id) is None:
+                raise OpValidationError(f"delete: target_id {op.target_id} not found")
+            if op.reason not in _DELETE_REASONS:
+                raise OpValidationError(f"delete: reason must be one of {sorted(_DELETE_REASONS)}")
+            if op.target_id in edits:
+                raise OpValidationError(
+                    f"batch conflict: edit and delete on same id {op.target_id}"
+                )
+            deletes.add(op.target_id)
+        else:
+            raise OpValidationError(f"unknown op {type(op).__name__}")
+
+
+def apply(doc: Document, ops: list[Op]) -> ApplyReport:
+    """Apply ops as an atomic batch. Mutates ``doc`` in place on success.
+
+    On validation failure the document is untouched and the report carries
+    ``accepted=False`` with ``reason``.
+    """
+    try:
+        _validate(doc, ops)
+    except OpValidationError as exc:
+        return ApplyReport(accepted=False, reason=str(exc))
+
+    results: list[OpResult] = []
+    for op in ops:
+        if isinstance(op, AddOp):
+            new_id = new_entry_id()
+            doc.section_entries(op.section).append(
+                Entry(id=new_id, section=op.section, text=op.text, refs=list(op.refs))
+            )
+            results.append(OpResult(op=op, status="applied", entry_id=new_id))
+        elif isinstance(op, EditOp):
+            entry = doc.find(op.target_id)
+            assert entry is not None  # _validate ensured this
+            entry.text = op.new_text
+            entry.refs = list(op.new_refs)
+            results.append(OpResult(op=op, status="applied"))
+        else:  # DeleteOp
+            doc.remove(op.target_id)
+            results.append(OpResult(op=op, status="applied", detail=op.reason))
+
+    return ApplyReport(accepted=True, results=results)

deeptutor/services/memory/paths.py

@@ -0,0 +1,104 @@
+"""Path resolution for the three-layer memory subsystem.
+
+Layout under the per-user memory root::
+
+    trace/<surface>/<YYYY-MM-DD>.jsonl    (L1, append-only)
+    L2/<surface>.md                       (L2, per-surface summaries)
+    L3/<recent|profile|scope|preferences>.md  (L3, cross-surface)
+    backup/<timestamp>/...                (v1 migration archive)
+
+The root itself is resolved via :class:`PathService` so the multi-user
+context (workspace_root) is picked up at call time, not import time.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from contextvars import ContextVar
+from datetime import date
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterator, Literal, get_args
+
+from deeptutor.services.path_service import get_path_service
+from deeptutor.utils.secret_files import ensure_private_directory
+
+if TYPE_CHECKING:
+    from deeptutor.services.path_service import PathService
+
+# When set, memory paths resolve through this PathService instead of the active
+# user's. A partner runtime installs the *owner's* (admin) service for the
+# duration of a turn so the chat agent's ``read_memory`` / ``write_memory``
+# tools see the owner's memory — not the partner's own (empty) scope — while
+# every *other* service (rag / skills / notebooks) stays on the partner scope.
+_memory_path_service: ContextVar[PathService | None] = ContextVar(
+    "memory_path_service", default=None
+)
+
+
+@contextlib.contextmanager
+def memory_path_service_override(service: PathService) -> Iterator[None]:
+    """Resolve memory paths through *service* within this context."""
+    token = _memory_path_service.set(service)
+    try:
+        yield
+    finally:
+        _memory_path_service.reset(token)
+
+
+Surface = Literal[
+    "chat",
+    "notebook",
+    "quiz",
+    "kb",
+    "book",
+    "partner",
+    "cowriter",
+]
+L3Slot = Literal["recent", "profile", "scope", "preferences"]
+
+SURFACES: tuple[Surface, ...] = get_args(Surface)
+L3_SLOTS: tuple[L3Slot, ...] = get_args(L3Slot)
+
+
+def memory_root() -> Path:
+    override = _memory_path_service.get()
+    service = override if override is not None else get_path_service()
+    return service.get_memory_dir()
+
+
+def trace_dir(surface: Surface) -> Path:
+    return memory_root() / "trace" / surface
+
+
+def trace_file(surface: Surface, day: date) -> Path:
+    return trace_dir(surface) / f"{day.isoformat()}.jsonl"
+
+
+def l2_dir() -> Path:
+    return memory_root() / "L2"
+
+
+def l2_file(surface: Surface) -> Path:
+    return l2_dir() / f"{surface}.md"
+
+
+def l3_dir() -> Path:
+    return memory_root() / "L3"
+
+
+def l3_file(slot: L3Slot) -> Path:
+    return l3_dir() / f"{slot}.md"
+
+
+def backup_root() -> Path:
+    return memory_root() / "backup"
+
+
+def ensure_dirs() -> None:
+    """Create the directory skeleton. Idempotent."""
+    root = memory_root()
+    ensure_private_directory(root)
+    l2_dir().mkdir(parents=True, exist_ok=True)
+    l3_dir().mkdir(parents=True, exist_ok=True)
+    for surface in SURFACES:
+        trace_dir(surface).mkdir(parents=True, exist_ok=True)

deeptutor/services/memory/prompts/en.yaml

@@ -0,0 +1,156 @@
+# Memory consolidation prompts (English).
+#
+# Used by deeptutor.services.memory.consolidator to turn raw L1 trace
+# events into L2 ops, and the seven L2 docs into L3 ops. Every prompt
+# uses the same output schema: {"ops": [...]}.
+
+system_l2: |
+  You are the memory curator for DeepTutor user {user_label}. You read
+  the user's current workspace entities (full content, not event logs)
+  for a single surface and propose surgical edit operations on that
+  surface's markdown memory document. You never chat, explain, or
+  apologise — you emit JSON only.
+
+  Today is {today}.
+
+  EVERY add/edit op MUST include `refs`: at least one entity reference
+  from the input, written as `<surface>:<entity_id>` (the `ref:` line
+  above each entity block tells you the exact string to cite). No refs
+  → do not emit. An empty `ops` list is a correct, expected output
+  when nothing material has changed.
+
+  Length cap: each `text`/`new_text` ≤ 240 characters. Be terse.
+
+  Banned phrases (unless quoted verbatim from the user, in which case
+  wrap them in 「 」): deeply, truly, mastered, expert, passionate,
+  loves, hates, always, never, fully understands.
+
+  Prefer verb phrases ("uses X", "prefers X over Y", "stuck on Z")
+  over adjectives. Quote the user's words for specific claims.
+
+  Delete reasons (enum): contradicted, superseded, stale, low-signal.
+
+user_l2: |
+  Surface: {surface}
+  Focus: {focus}
+  Suggested sections (use these names; add new sections only if
+  clearly needed): {sections}
+
+  Existing document (each entry is annotated with its `[m_xxx]` id):
+  ----
+  {existing}
+  ----
+
+  Current workspace entities (one block per item, each block shows
+  the `ref:` you must cite, the label, timestamp, metadata, and FULL
+  content):
+  ----
+  {entities}
+  ----
+
+  Changes since last refresh (informational; do NOT cite these as refs):
+  ----
+  {changes}
+  ----
+
+  Recent KB queries (only present for the `kb` surface):
+  ----
+  {kb_queries}
+  ----
+
+  Emit a JSON object with this shape exactly:
+
+  {{
+    "ops": [
+      {{"op": "add",    "section": "<one of the sections>", "text": "<≤240 chars>", "refs": ["<surface>:<entity_id>", ...]}},
+      {{"op": "edit",   "target_id": "<m_xxx>", "new_text": "<≤240 chars>", "new_refs": ["<surface>:<entity_id>", ...]}},
+      {{"op": "delete", "target_id": "<m_xxx>", "reason": "<contradicted|superseded|stale|low-signal>"}}
+    ]
+  }}
+
+  If nothing material changed, emit {{"ops": []}}. Do not wrap output
+  in markdown fences. Do not add any prose.
+
+system_l3: |
+  You are the cross-surface memory curator for DeepTutor user
+  {user_label}. You read the seven per-surface summaries (L2) and
+  propose surgical edit operations on ONE cross-surface document.
+  You never chat, explain, or apologise — you emit JSON only.
+
+  Today is {today}.
+
+  OBJECTIVITY IS NON-NEGOTIABLE for L3. Hard rules:
+
+  1. Every claim MUST cite ≥1 L2 entry id in `refs` (form m_xxx).
+     No refs → do not emit.
+  2. Banned absolutist phrasing: deeply, truly, mastered, expert,
+     passionate, loves, hates, always, never, fully understands.
+     Use only if quoting the user verbatim 「like this」.
+  3. Forced hedge template — claims about the user must take the
+     form: "Across N <surface> interactions, the user X". Bind
+     observations to a count or a surface.
+
+  Length cap 240 chars per entry. Be terse.
+
+  Delete reasons (enum): contradicted, superseded, stale, low-signal.
+
+user_l3: |
+  Slot: {slot}
+  Focus: {focus}
+  Suggested sections: {sections}
+
+  Existing document:
+  ----
+  {existing}
+  ----
+
+  Seven L2 surface summaries (with their entry ids):
+  ----
+  {l2_corpus}
+  ----
+
+  Emit JSON in this exact shape:
+
+  {{
+    "ops": [
+      {{"op": "add",    "section": "<section>", "text": "<≤240 chars, hedged>", "refs": ["m_xxx", ...]}},
+      {{"op": "edit",   "target_id": "<m_xxx>", "new_text": "<≤240 chars, hedged>", "new_refs": ["m_xxx", ...]}},
+      {{"op": "delete", "target_id": "<m_xxx>", "reason": "<contradicted|superseded|stale|low-signal>"}}
+    ]
+  }}
+
+  Empty `ops` is fine and expected when no L2 changes warrant L3 motion.
+
+surfaces:
+  chat:
+    focus: "Stable misconceptions the user has surfaced, concepts they've demonstrated mastery of, and durable topics they keep returning to. Drop per-turn chatter."
+    sections: ["Misconceptions", "Mastery", "Topics"]
+  notebook:
+    focus: "Recurring note themes, formats the user prefers, and questions they keep coming back to in their notes."
+    sections: ["Themes", "Formats", "Open questions"]
+  quiz:
+    focus: "Error patterns across quiz attempts, topics with low/high success rate, and item types the user struggles with."
+    sections: ["Error patterns", "Strong topics", "Struggling topics"]
+  kb:
+    focus: "Document interests, query patterns into the knowledge base, and gaps in user's library."
+    sections: ["Interests", "Frequent queries", "Library gaps"]
+  book:
+    focus: "Reading pacing, sticking points (pages reopened or paused), and topics the user annotates heavily."
+    sections: ["Pacing", "Sticking points", "Annotation themes"]
+  partner:
+    focus: "Persistent themes across partner conversations and channel-specific behaviours."
+    sections: ["Themes", "Channels"]
+  cowriter:
+    focus: "Writing style preferences, recurring revisions, and topics the user drafts about."
+    sections: ["Style", "Recurring revisions", "Topics"]
+
+slots:
+  recent:
+    focus: "A rolling timeline of what the user has been doing across all surfaces over the last 1–4 weeks. Time-anchored, surface-attributed."
+    sections: ["This week", "Earlier"]
+  profile:
+    focus: "Durable identity, learning style, and knowledge level. ONLY claims supported by multiple L2 entries across surfaces. No speculation about traits not directly evidenced."
+    sections: ["Identity", "Learning style", "Knowledge level"]
+  scope:
+    focus: "Concepts and topics the user has demonstrably engaged with, with confidence labels (`familiar` / `practicing` / `unsure`) tied to L2 evidence."
+    sections: ["Familiar", "Practicing", "Unsure"]

deeptutor/services/memory/prompts/zh.yaml

@@ -0,0 +1,144 @@
+# 记忆 consolidation prompts（中文）。
+
+system_l2: |
+  你是 DeepTutor 用户 {user_label} 的记忆策展员。你的工作是读取
+  单个 surface 的**当前 workspace 实体内容**（不是事件流——是文档/
+  记录/会话的完整原文），然后对该 surface 的 markdown 记忆文档
+  发起外科式的修改操作。你不聊天、不解释、不道歉——只输出 JSON。
+
+  今天是 {today}。
+
+  每条 add/edit 必须带 `refs`：至少一个来自输入的实体引用，格式
+  为 `<surface>:<entity_id>`（每个实体块上方的 `ref:` 行直接给你
+  要引用的字符串）。没有引用就不要输出。当没有实质变化时，输出
+  空 `ops` 数组是正确的、被期望的答案。
+
+  长度上限：每条 `text`/`new_text` ≤ 240 字符。要简短。
+
+  禁用词（除非引用用户原话，那要用 「 」 包起来）：深刻、彻底、
+  完美掌握、专家、热爱、总是、从来不、完全理解。
+
+  用动词短语（"使用 X"、"偏好 X 不偏好 Y"、"卡在 Z"），不用形容
+  词。要做具体陈述就引用用户原话。
+
+  删除理由（枚举）：contradicted、superseded、stale、low-signal。
+
+user_l2: |
+  Surface: {surface}
+  Focus: {focus}
+  建议 section（请使用这些名字，仅在必要时新增）: {sections}
+
+  当前文档（每条 entry 后标有 `[m_xxx]` 形式的 id）：
+  ----
+  {existing}
+  ----
+
+  当前 workspace 实体（一个块一个项目，每块顶端的 `ref:` 就是
+  你必须引用的字符串，含 label / ts / metadata / 完整 content）：
+  ----
+  {entities}
+  ----
+
+  自上次 refresh 起的变更（仅供参考，不要把这些作为 refs 引用）：
+  ----
+  {changes}
+  ----
+
+  最近的 KB 查询（仅 `kb` surface 有内容）：
+  ----
+  {kb_queries}
+  ----
+
+  按以下 JSON 结构精确输出：
+
+  {{
+    "ops": [
+      {{"op": "add",    "section": "<section 之一>", "text": "<≤240 字符>", "refs": ["<surface>:<entity_id>", ...]}},
+      {{"op": "edit",   "target_id": "<m_xxx>", "new_text": "<≤240 字符>", "new_refs": ["<surface>:<entity_id>", ...]}},
+      {{"op": "delete", "target_id": "<m_xxx>", "reason": "<contradicted|superseded|stale|low-signal>"}}
+    ]
+  }}
+
+  如果没有实质变化，输出 {{"ops": []}}。不要用 markdown 代码块包裹。
+  不要输出任何额外说明文字。
+
+system_l3: |
+  你是 DeepTutor 用户 {user_label} 的跨 surface 记忆策展员。你读取
+  七份 per-surface 小结（L2），然后对**一份**跨 surface 的全局文档
+  发起外科式的修改操作。你不聊天、不解释、不道歉——只输出 JSON。
+
+  今天是 {today}。
+
+  L3 必须客观，这一条不可商量。硬规则：
+
+  1. 每条结论必须在 `refs` 中至少引用 1 个 L2 entry id（m_xxx 形式）。
+     没引用不要输出。
+  2. 禁用绝对化词汇：深刻、彻底、完美掌握、专家、热爱、总是、从来
+     不、完全理解。仅在引用用户原话「这样」时才允许使用。
+  3. 强制 hedge 模板——关于用户的陈述必须形如："在 N 次 <surface>
+     互动中，用户 X"。把"观察"和"用户判断"绑死。
+
+  长度上限：每条 240 字符。要简短。
+
+  删除理由（枚举）：contradicted、superseded、stale、low-signal。
+
+user_l3: |
+  Slot: {slot}
+  Focus: {focus}
+  建议 section: {sections}
+
+  当前文档：
+  ----
+  {existing}
+  ----
+
+  七份 L2 surface 小结（含 entry id）：
+  ----
+  {l2_corpus}
+  ----
+
+  按以下 JSON 结构精确输出：
+
+  {{
+    "ops": [
+      {{"op": "add",    "section": "<section>", "text": "<≤240 字符，带 hedge>", "refs": ["m_xxx", ...]}},
+      {{"op": "edit",   "target_id": "<m_xxx>", "new_text": "<≤240 字符，带 hedge>", "new_refs": ["m_xxx", ...]}},
+      {{"op": "delete", "target_id": "<m_xxx>", "reason": "<contradicted|superseded|stale|low-signal>"}}
+    ]
+  }}
+
+  没有需要变化时输出 {{"ops": []}}。
+
+surfaces:
+  chat:
+    focus: "用户暴露出来的稳定误解、已展示掌握的概念、反复回来的持久话题。临时的对话噪声不要记。"
+    sections: ["误解", "掌握", "话题"]
+  notebook:
+    focus: "笔记里反复出现的主题、用户偏好的格式、笔记里反复回到的问题。"
+    sections: ["主题", "格式偏好", "开放问题"]
+  quiz:
+    focus: "做题中的错误模式、正确率高/低的话题、用户卡住的题型。"
+    sections: ["错误模式", "擅长话题", "薄弱话题"]
+  kb:
+    focus: "感兴趣的文档、向知识库发起的查询模式、用户资料库的盲区。"
+    sections: ["兴趣方向", "高频查询", "资料盲区"]
+  book:
+    focus: "阅读节奏、卡点（被重新打开或停留的页）、用户重度批注的话题。"
+    sections: ["节奏", "卡点", "批注主题"]
+  partner:
+    focus: "伙伴对话中跨次出现的主题、频道相关的特定行为。"
+    sections: ["主题", "频道行为"]
+  cowriter:
+    focus: "写作风格偏好、反复改的地方、用户起草的话题。"
+    sections: ["风格", "反复修订", "话题"]
+
+slots:
+  recent:
+    focus: "用户最近 1–4 周在各 surface 上做了什么的滚动时间线。带时间，标 surface 出处。"
+    sections: ["本周", "更早"]
+  profile:
+    focus: "稳定的身份、学习风格、知识水平。仅当多个 L2 entry（跨 surface）共同支持时才能下断言。没直接证据的特质不要猜。"
+    sections: ["身份", "学习风格", "知识水平"]
+  scope:
+    focus: "用户已有实证接触的概念/话题，附置信度标签（`熟悉` / `练习中` / `不确定`），均挂回 L2 证据。"
+    sections: ["熟悉", "练习中", "不确定"]