memleaf 0.2.64__tar.gz → 0.2.65__tar.gz

{memleaf-0.2.64 → memleaf-0.2.65}/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.65 — 2026-09-16
+
+- Ground maintenance todo deadlines in Core-validated candidate evidence and `reference_time`. Relative calendar ranges resolve deterministically to their last valid day, while the normalized deadline view removes only formatting and equivalent parenthetical restatements without losing conflicting dates.
+- Keep validated dates and bounded evidence references intact through maintenance review. Todo candidates now carry explicit status/deadline fields, numeric reference strings are normalized safely, and the shared retention contract stays focused on future collaborative value.
+
+Verification: Python 3.11 compilation, package metadata consistency, wheel contents and `git diff --check` were checked. The release CI verifies the built distributions and entry points.
+
 ## 0.2.64 — 2026-09-16
 
 - Keep uncertain ownership as `unscoped`: explicit cross-project corrections now require cited user evidence and an exact target, while independent project subjects are deferred instead of guessed. Candidate-local deadline grounding remains conservative, preserving only dates tied to the todo action or its explicit task basis.

{memleaf-0.2.64/src/memleaf.egg-info → memleaf-0.2.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.64
+Version: 0.2.65
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.64。**
+> **版本：0.2.65。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。

{memleaf-0.2.64 → memleaf-0.2.65}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.64.**
+> **Version: 0.2.65.**
 > Automatic extraction and review share one future-value standard: the model weighs likely reuse, information gain, direct usability when read again, and the cost of forgetting. It keeps only the smallest core that can materially help future understanding, decisions, or actions; information without clear value is not extracted, and no business-specific exclusion rule is hard-coded.
 > A single Chinese semantic contract is sent for extraction, topic selection, candidate repair, and `semantic_maintenance`; the older English B3 prompt has been deleted and B3 remains only as a compatibility read format. One topic is written once.
 > Core no longer discards a whole candidate over ownership, dates, task basis or cross-project wording. A missing owner normalizes to the single project named by that candidate's own evidence, otherwise `global`. A deadline is accepted only when it appears in the candidate's own evidence and can be anchored to ISO (`明天`, `周五`, `月底` all resolve); when it cannot, only the date field is dropped and the memory is still written. An unauthorized ownership change keeps the target's existing scope.

{memleaf-0.2.64 → memleaf-0.2.65}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.64。**
+> **版本：0.2.65。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。

{memleaf-0.2.64 → memleaf-0.2.65}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memleaf"
-version = "0.2.64"
+version = "0.2.65"
 description = "A local-first Markdown memory core for AI agents"
 readme = "README.md"
 requires-python = ">=3.11"

{memleaf-0.2.64 → memleaf-0.2.65}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.64"
+__version__ = "0.2.65"
 
 from .config import DEFAULT_CONFIG, default_config, load_config, save_config
 from .frontmatter import FrontmatterError, dump_frontmatter, dump_yaml, load_yaml, parse_frontmatter

{memleaf-0.2.64 → memleaf-0.2.65}/src/memleaf/hermes_provider/plugin.yaml

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.64
+version: 0.2.65
 description: "Hermes-native external MemoryProvider for local-first Markdown memory shared with the memleaf MCP server."
 hooks:
   - prefetch

{memleaf-0.2.64 → memleaf-0.2.65}/src/memleaf/process_common.py

@@ -894,6 +894,38 @@ def _grounded_due_dates(
     return result
 
 
+def _deadline_evidence_text(content: str, anchor: Any) -> str:
+    """Normalize presentation only in the deadline view, never stored evidence."""
+    text = content
+    for marker in ("**", "__", "`", "*", "_"):
+        pattern = re.escape(marker) + r"([^\n]+?)" + re.escape(marker)
+        text = re.sub(pattern, lambda match: match.group(1), text)
+    normalized = normalize_relative_calendar_text(text, anchor) if anchor is not None else None
+    text = normalized if normalized is not None else text
+    # A parenthetical restatement of the same date must not separate it from
+    # 'before'. Keep arbitrary notes and conflicting dates intact.
+    for token in reversed(calendar_tokens(text, anchor)):
+        if token.canonical is None:
+            continue
+        note = re.match(r"[（(]([^()（）\n]+)[）)]", text[token.end:])
+        if note is None:
+            continue
+        inner = note.group(1)
+        dates = calendar_tokens(inner, anchor)
+        if any(item.canonical != token.canonical for item in dates):
+            continue
+        for item in reversed(dates):
+            inner = inner[:item.start] + inner[item.end:]
+        weekdays = re.findall(r"(?:周|星期)([一二三四五六日天])", inner)
+        weekday = datetime.fromisoformat(token.canonical).weekday()
+        if any("一二三四五六日".index(day.replace("天", "日")) != weekday for day in weekdays):
+            continue
+        inner = re.sub(r"(?:周|星期)[一二三四五六日天]", "", inner)
+        if (dates or weekdays) and not inner.strip(" ，,、\t"):
+            text = text[:token.end] + text[token.end + note.end():]
+    return text
+
+
 def _grounded_deadline_dates(
     evidence_events: Iterable[Mapping[str, Any]],
 ) -> set[str]:
@@ -912,9 +944,7 @@ def _grounded_deadline_dates(
         if not isinstance(content, str) or not content:
             continue
         timestamp = _parse_time(event.get("timestamp"))
-        text = normalize_relative_calendar_text(content, timestamp) if timestamp is not None else content
-        if text is None:
-            text = content
+        text = _deadline_evidence_text(content, timestamp)
         for token in calendar_tokens(text, timestamp):
             canonical = token.canonical
             if canonical is None:

{memleaf-0.2.64 → memleaf-0.2.65}/src/memleaf/semantic_maintenance.py

@@ -5,21 +5,38 @@ from typing import Any, Mapping
 from .semantic_protocol import RETENTION_GUIDANCE, expand_fragments, _invalid
 from .validation import ModelOutputError, parse_strict_json
 
-MAINTENANCE_SYSTEM = RETENTION_GUIDANCE + "\n" + '''根据 incoming 引用的原始证据维护长期记忆；incoming 仅划定待复核的主题，不提供已确认的分类或归属。catalog 是可更新的已有记忆。先识别已有事项的状态变化，再判断新建价值。同一事项合并维护当前状态，重复不新建；完成或转交也应维护已有 todo，不能另建完成事实留下旧待办。
-返回 JSON {"memories":[{"from":["d1"],"target":null,"title":"简短主题","body":"最小可复用核心","type":"fact","scope":"global","evidence":[片段ID]}],"discard":[],"deferred":[]}。
-每条一个独立主体与用途，可拆分同一 incoming。scope 按证据独立确定为 project:主体名、global（通用原则）或 unscoped（归属未确定）。type 为 fact/preference/project/todo/event/identity/other。target 为同事项的 catalog 真实ID，无才为null；更新保留原type，明确归属纠正可以改变scope。todo 提供 status（active/completed/cancelled）和 due_date（明确行动期限的原文写法，无则null）。正文保留当前有效内容，去掉过时状态和无复用价值的细节。每个 incoming 用 from、discard 或 deferred 覆盖；from 表示该主题已完整复核，evidence 只绑定保留内容，其余细节不记忆。from 和 evidence 只能选输入中已有的编号。'''
+MAINTENANCE_SYSTEM = RETENTION_GUIDANCE + "\n" + '''根据 incoming 引用的原始证据维护长期记忆；incoming 仅划定待复核的主题，不提供已确认的分类或归属，其中已有的 due_date 是 Core 按证据和 reference_time 校验过的期限，须原样用于 due_date 和正文。catalog 是可更新的已有记忆。先识别已有事项的状态变化，再判断新建价值。同一事项合并维护当前状态，重复不新建；完成或转交也应维护已有 todo，不能另建完成事实留下旧待办。
+返回 JSON {"memories":[{"from":["d1"],"target":null,"title":"简短主题","body":"最小可复用核心","type":"fact","scope":"global"}],"discard":[],"deferred":[]}。
+每条一个独立主体与用途，可拆分同一 incoming。scope 按证据独立确定为 project:主体名、global（通用原则）或 unscoped（归属未确定）。type 为 fact/preference/project/todo/event/identity/other。target 为同事项的 catalog 真实ID，无才为null；更新保留原type，明确归属纠正可以改变scope。新 todo 须有用户明确承担未完成动作的证据。todo 必须显式提供 status（active/completed/cancelled）和 due_date（无则null）。reference_time 是当前会话时间；按原始约定把可换算的相对期限写成 YYYY-MM-DD，范围取最晚完成日，正文同步使用该日期。无法可靠换算则 due_date:null，但保留核心记忆。正文保留当前有效内容，去掉过时状态和无复用价值的细节。每个 incoming 用 from、discard 或 deferred 覆盖；from 表示该主题已完整复核。仅拆分同一 incoming 时填写 evidence:[fragments.id] 来绑定各自保留内容，否则省略 evidence。所有引用只能选输入中已有的编号。'''
 
 
-def maintenance_input(raw: str, fragments: list[dict[str, Any]], catalog: list[dict[str, Any]], model_data: Mapping[str, Any]):
+def maintenance_input(
+    raw: str,
+    fragments: list[dict[str, Any]],
+    catalog: list[dict[str, Any]],
+    model_data: Mapping[str, Any],
+    validated: Mapping[str, Any] | None = None,
+):
     # Validate exact references before they become trusted input to maintenance.
     expand_fragments(raw, fragments)
     original = parse_strict_json(raw)
     incoming = {}
     proposals = []
     catalog_ids = {m['memory_id'].casefold() for m in catalog}
+    validated_by_id = {
+        item['candidate_id']: item
+        for item in (validated.get('items', []) if isinstance(validated, Mapping) else [])
+        if isinstance(item, Mapping) and isinstance(item.get('candidate_id'), str)
+    }
     for index, row in enumerate(original['memories'], 1):
         incoming[index] = dict(row)
         proposal = {'id': f'd{index}', 'evidence': row['evidence']}
+        accepted = validated_by_id.get(f'c{index}')
+        accepted_memory = accepted.get('memory') if isinstance(accepted, Mapping) else None
+        accepted_due_date = accepted_memory.get('due_date') if isinstance(accepted_memory, Mapping) else None
+        if isinstance(accepted_due_date, str) and accepted_due_date:
+            proposal['due_date'] = accepted_due_date
+            incoming[index]['_confirmed_due_date'] = accepted_due_date
         if isinstance(row.get('target'), str) and row['target'].casefold() in catalog_ids:
             proposal['target'] = row['target']
         proposals.append(proposal)
@@ -28,6 +45,8 @@ def maintenance_input(raw: str, fragments: list[dict[str, Any]], catalog: list[d
     # must be able to correct ownership and value without inheriting them.
     snippets = list(model_data['fragments'])
     payload = {'incoming': proposals, 'catalog': related, 'fragments': snippets}
+    if isinstance(model_data.get('reference_time'), str) and model_data['reference_time']:
+        payload['reference_time'] = model_data['reference_time']
     return payload, (original, incoming, {m['memory_id'].casefold():m for m in related})
 
 
@@ -123,8 +142,28 @@ def expand_maintenance(raw: str, context, *, diagnostics=None) -> str:
         if kind != 'todo':
             for field in ('status', 'due_date', 'completed_at'):
                 memory.pop(field, None)
+        else:
+            confirmed_due_dates = {
+                source.get('_confirmed_due_date')
+                for source in sources
+                if isinstance(source.get('_confirmed_due_date'), str)
+                and source['_confirmed_due_date']
+            }
+            if len(confirmed_due_dates) > 1:
+                raise _invalid('invalid_due_date')
+            if confirmed_due_dates:
+                confirmed_due_date = next(iter(confirmed_due_dates))
+                proposed_due_date = memory.get('due_date')
+                if isinstance(proposed_due_date, str) and proposed_due_date != confirmed_due_date:
+                    for field in ('title', 'body'):
+                        if isinstance(memory.get(field), str):
+                            memory[field] = memory[field].replace(proposed_due_date, confirmed_due_date)
+                memory['due_date'] = confirmed_due_date
         allowed = list(dict.fromkeys(int(r) for s in sources for r in s['evidence']))
         chosen = row.get('evidence', allowed)
+        if isinstance(chosen, list):
+            chosen = [int(r) if isinstance(r, str) and len(r) <= 20 and r.isascii() and r.isdecimal() else r
+                      for r in chosen]
         if not isinstance(chosen, list) or not chosen or any(type(r) is not int or r not in allowed for r in chosen):
             raise _invalid('invalid_evidence')
         memory['evidence']=list(dict.fromkeys(chosen))

{memleaf-0.2.64 → memleaf-0.2.65}/src/memleaf/semantic_protocol.py

@@ -107,14 +107,14 @@ def source_fragments(b3_prompt: str) -> dict[str, Any]:
             'scope_context': data['scope_background'], 'scope_registry': data['scope_registry']}
 
 
-RETENTION_GUIDANCE = """长期记忆服务于未来协作，不是业务流水归档。保留持续事项的行动与状态、稳定偏好及可直接复用的知识；仅供本次查阅知悉的通知、过程记录不保留。事实成立或能想象用途并不足够，未来仍须重新查询来源才可信的信息通常不保留。只留下有明确未来用途的最小核心，无此价值放 no_memory；已有事项的状态变化仍须更新。retention=reusable 表示可复用，session 表示仅本轮有用。"""
+RETENTION_GUIDANCE = """长期记忆服务于未来协作，不是业务流水归档。保留持续事项的行动与状态、稳定偏好及可直接复用的知识；仅供本次查阅知悉的通知、过程记录不保留。事实成立或能想象用途并不足够，未来仍须重新查询来源才可信的信息通常不保留。只留下有明确未来用途的最小核心；已有事项的状态变化仍须更新。"""
 
 
 FRAGMENT_SYSTEM = f'''根据对话语义判断每段信息是否值得形成长期记忆，不继承原文的标题、紧急程度、列表分类或建议处理方式。
 {RETENTION_GUIDANCE}
 返回 JSON：{{"memories":[],"no_memory":[],"deferred":[]}}。
-每条 memory：{{"retention":"reusable 或 session","title":"简短主题","body":"脱离本轮对话仍有价值的核心内容","scope":"project:主体名 或 global","evidence":[片段ID]}}。type 默认 fact，表示业务事实或状态；可选类型 preference、project、todo、event、identity、other，event 仅用于事件本身而非其携带的业务事实。一条一个独立主题与归属，同一件事只写一次。scope 表示事实所属主体，按语义判断，不要求名称与证据逐字一致；项目、客户、系统、产品等主体均可作为归属，通用原则写 global，主体所属项目尚未确认写 unscoped，不根据名称相似或当前项目猜测。同一段的独立主题分别提炼。
-新 todo 额外提供 task_basis:[用户角色片段ID]，其内容须明确建立用户自己承担的未完成动作。todo 提供 status（active/completed/cancelled）及 due_date（该任务约定日期，无则 null），completed_at 可选。日期保留原文写法，由 Core 解析相对日期。
+每条 memory：{{"retention":"reusable（可复用）或 session（仅本轮）","title":"简短主题","body":"脱离本轮对话仍有价值的核心内容","scope":"project:主体名 或 global","evidence":[片段ID]}}。type 默认 fact，表示业务事实或状态；可选类型 preference、project、todo、event、identity、other，event 仅用于事件本身而非其携带的业务事实。一条一个独立主题与归属，同一件事只写一次。scope 表示事实所属主体，按语义判断，不要求名称与证据逐字一致；项目、客户、系统、产品等主体均可作为归属，通用原则写 global，主体所属项目尚未确认写 unscoped，不根据名称相似或当前项目猜测。同一段的独立主题分别提炼。
+新 todo 额外提供 task_basis:[用户角色片段ID]，其内容须明确建立用户自己承担的未完成动作。todo 必须显式提供 status（active/completed/cancelled）和 due_date（无则 null），completed_at 可选。reference_time 是当前会话时间；按原始约定把可换算的相对期限写成 YYYY-MM-DD，范围取最晚完成日，正文同步使用该日期。无法可靠换算则 due_date:null，但保留核心记忆。
 no_memory 填不符合上述长期记忆价值标准的片段ID；deferred 填语义尚无法确定的片段ID。每个片段须被 memory 引用或列入其中一个数组。同片段允许支持多条 memory。若为 catalog 中同一事项的补充、状态变化或重复，target 填已有真实 ID 并给出合并后的当前内容；新事项才省略 target。无需输出写入决策、生成ID或复制原文。'''
 
 
@@ -217,7 +217,7 @@ def _independent_project_subjects(text: str, scope_registry: Mapping[str, Any] |
 
 TOPIC_SYSTEM = RETENTION_GUIDANCE + "\n" + '''根据对话语义识别值得保留的独立主题，不继承原文标题、紧急程度、列表分类或建议处理方式。
 这一阶段只选择有后续价值的主题及其证据，不写记忆正文，不分类，不处理日期，不决定数据库操作。
-返回 JSON {"topics":[{"retention":"reusable 或 session","scope":"project:项目名 或 global","evidence":[片段ID]}],"no_memory":[片段ID],"deferred":[片段ID]}。
+返回 JSON {"topics":[{"retention":"reusable（可复用）或 session（仅本轮）","scope":"project:项目名 或 global","evidence":[片段ID]}],"no_memory":[片段ID],"deferred":[片段ID]}。
 每个独立主题单独列出，scope 表示主题真正所属的主体，按语义判断，不要求名称与证据逐字一致；通用原则写 global，主体所属项目尚未确认写 unscoped，不根据名称相似或当前项目猜测。其他合法 scope：domain:名称、portfolio:名称、unscoped。
 no_memory 表示不符合上述长期记忆价值标准；deferred 表示语义无法确定。覆盖所有片段，每个被一个或多个主题引用或列入一个数组。'''
 

{memleaf-0.2.64 → memleaf-0.2.65}/src/memleaf/single_pass_memory_planner.py

@@ -28,6 +28,7 @@ from .process_common import (
     _event_payload,
     _explicit_project_scope_labels,
     _grounded_deadline_dates,
+    _deadline_evidence_text,
     _grounded_due_dates,
     _normalize_summary_dates,
     _parse_time,
@@ -60,8 +61,7 @@ def _candidate_deadline_dates(evidence: Iterable[Mapping[str, Any]]) -> set[str]
     for event in evidence:
         anchor = _parse_time(event.get("timestamp"))
         content = str(event.get("content", ""))
-        text = normalize_relative_calendar_text(content, anchor) if anchor is not None else content
-        text = text if text is not None else content
+        text = _deadline_evidence_text(content, anchor)
         for token in reversed(calendar_tokens(text, anchor)):
             if (re.search(r"(?:截至|截止)\s*[:：]?\s*$", text[:token.start])
                     and not _SCHEDULE_ACTION_RE.match(text[token.end:])):

{memleaf-0.2.64 → memleaf-0.2.65}/src/memleaf/single_pass_plan.py

@@ -1288,6 +1288,10 @@ def run_single_pass_stage(
             result["paragraph"] = paragraph
         return result
     model_data = {**fragment_data, "fragments": [visible_fragment(f) for f in fragment_data["fragments"]]}
+    reference_time = next((f.get("timestamp") for f in reversed(fragment_data["fragments"])
+                           if isinstance(f.get("timestamp"), str) and f["timestamp"]), None)
+    if reference_time is not None:
+        model_data["reference_time"] = reference_time
     compact_prompt = "MEMORY_INPUT\n" + json.dumps(model_data, ensure_ascii=False, separators=(",", ":"))
     primary_prompt = FRAGMENT_SYSTEM + "\n\n" + compact_prompt if inline_system else compact_prompt
     primary_system = "" if inline_system else FRAGMENT_SYSTEM
@@ -1702,7 +1706,9 @@ def run_single_pass_stage(
         maintenance_context = None
         if "memories" in value:
             from .semantic_maintenance import maintenance_input, MAINTENANCE_SYSTEM
-            review_payload, maintenance_context = maintenance_input(raw, repair_fragments, local_rows, model_data)
+            review_payload, maintenance_context = maintenance_input(
+                raw, repair_fragments, local_rows, model_data, validated=parsed,
+            )
             review_system = MAINTENANCE_SYSTEM
         review_prompt = "MEMORY_REVIEW\n" + json.dumps(review_payload, ensure_ascii=False, separators=(",", ":"))
         if inline_system:

{memleaf-0.2.64 → memleaf-0.2.65}/src/memleaf/validation.py

@@ -597,10 +597,10 @@ def _resolve_relative_date(token: str, anchor: date) -> str | None:
     )
     if chinese_match:
         prefix, weekday = chinese_match.groups()
-        # 周末 has no single safe calendar date; leave it for strict
-        # validation/deferred-candidate handling instead of guessing Sunday.
+        # A deadline expressed as a calendar range uses its last day. This
+        # matches the model contract and makes 周末 deterministic as Sunday.
         if weekday == "末":
-            return None
+            weekday = "日"
         week_offset = {"本": 0, "这": 0, "下": 1, "上": -1}[prefix]
         try:
             monday = anchor - timedelta(days=anchor.weekday())

{memleaf-0.2.64 → memleaf-0.2.65/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.64
+Version: 0.2.65
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.64。**
+> **版本：0.2.65。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。