memleaf 0.2.63__tar.gz → 0.2.65__tar.gz

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

@@ -2,6 +2,20 @@
 
 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.
+- Preserve target type and Core-owned ownership metadata during same-target reconciliation, and carry bounded `scope_drift` and schema diagnostics through maintenance and repair without rewriting valid sibling candidates.
+
+Verification: Python 3.11 compilation, package metadata consistency, wheel contents and `git diff --check` were checked. Provider/runtime acceptance is completed by the release CI and post-install replay.
+
 ## 0.2.63 — 2026-09-16
 
 - Unify the retention decision across first-pass extraction, topic selection, candidate repair and `semantic_maintenance`. The model now judges future reuse, information gain, direct usability and forgetting cost, keeping only the smallest core with clear material value; the contract contains no mail, report, customer or project-specific exclusion rule.

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.63"
+__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.63 → memleaf-0.2.65}/src/memleaf/hermes_provider/plugin.yaml

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.63
+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.63 → memleaf-0.2.65}/src/memleaf/planning_context.py

@@ -772,8 +772,8 @@ class PlanningContext:
     ) -> dict[str, Any] | None:
         """Authorize one explicit cross-project correction without guessing.
 
-        The current user turn must name exactly two configured project scopes
-        under explicit correction wording. A model-provided target is checked
+        The cited user evidence must name the new project under explicit
+        correction wording; an exact target establishes the previous owner. A model-provided target is checked
         against that evidence; when it is omitted, Core may recover exactly one
         same-type, same-topic active memory from the explicitly named old
         scope. Zero or multiple matches stay deferred rather than becoming a
@@ -793,10 +793,18 @@ class PlanningContext:
             event.content for event in turn.events
             if event.role == "user" and isinstance(event.content, str)
         ).strip()
+        bindings = candidate.get("_evidence_bindings", [])
+        quotes = [binding.get("quote") for binding in bindings if isinstance(binding, Mapping)]
+        cited_user_text = [quote for quote in quotes if isinstance(quote, str) and quote and quote in user_text]
+        if cited_user_text:
+            user_text = " ".join(cited_user_text)
         if not user_text or not _SCOPE_CORRECTION_MARKER_RE.search(user_text):
             return None
         config = config if "scopes" in config else {"scopes": config}
-        scopes = config.get("scopes", {}) if isinstance(config.get("scopes", {}), Mapping) else {}
+        scopes = dict(config.get("scopes", {})) if isinstance(config.get("scopes", {}), Mapping) else {}
+        # Explicit user corrections can introduce a previously unseen owner;
+        # local matching still requires that new name in the cited evidence.
+        scopes.setdefault(new_scope, {})
         mentioned = [
             scope for scope in scopes
             if isinstance(scope, str)
@@ -804,9 +812,19 @@ class PlanningContext:
             and self._scope_terms_present(user_text, scope, config)
         ]
         mentioned = list(dict.fromkeys(mentioned))
-        if len(mentioned) != 2 or all(scope.casefold() != new_scope.casefold() for scope in mentioned):
-            return None
-        old_scope = next(scope for scope in mentioned if scope.casefold() != new_scope.casefold())
+        selected = self._active_memory_by_id(candidate.get("update_memory_id"))
+        if selected is not None and len(selected.scopes) == 1:
+            # Other projects in the same user turn do not invalidate an exact
+            # correction of this selected target. The new owner must occur
+            # in the cited user correction; the old owner is the target's
+            # existing metadata, not an inference from another sentence.
+            old_scope = selected.scopes[0]
+            if new_scope not in mentioned or old_scope == new_scope:
+                return None
+        else:
+            if len(mentioned) != 2 or new_scope not in mentioned:
+                return None
+            old_scope = next(scope for scope in mentioned if scope != new_scope)
 
         topic = str(candidate.get("memory") or "")
         removable_terms: list[str] = []

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

@@ -74,7 +74,7 @@ _DEADLINE_PREFIX_RE = re.compile(
     re.IGNORECASE,
 )
 _DEADLINE_SUFFIX_RE = re.compile(
-    r"^\s*(?:(?:[01]?\d|2[0-3]):[0-5]\d\s*)?(?:前|之前|为止|截止|截至|不晚于|不得晚于|before\b|deadline\b|due\b)",
+    r"^\s*(?:(?:[01]?\d|2[0-3]):[0-5]\d\s*|(?:上午|下午|晚上|下班|中午|凌晨|傍晚|晚间)(?:\d{1,2}(?:点|时))?\s*)?(?:前|之前|为止|截止|截至|不晚于|不得晚于|before\b|deadline\b|due\b)",
     re.IGNORECASE,
 )
 _EXPLICIT_PROJECT_LABEL_RE = re.compile(
@@ -89,7 +89,7 @@ _EXPLICIT_PROJECT_LABEL_RE = re.compile(
 
 
 _SCOPE_CORRECTION_MARKER_RE = re.compile(
-    r"(?:不是|并非|不属于|归错|归属错误|错误归属|应属于|应该属于|改归|改为|纠正为|"
+    r"(?:不是|并非|不属于|归错|归属错误|错误归属|应属于|应该属于|应该(?:是|说)|改归|改为|纠正为|"
     r"wrong\s+(?:project|scope)|belongs?\s+to|correct\s+(?:project|scope))",
     re.IGNORECASE,
 )
@@ -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.65/src/memleaf/semantic_maintenance.py

@@ -0,0 +1,218 @@
+"""Maintain scoped memory state from small, already evidence-bound deltas."""
+from __future__ import annotations
+import json
+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 仅划定待复核的主题，不提供已确认的分类或归属，其中已有的 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],
+    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)
+    related = [m for m in catalog if len(m.get('scopes', [])) == 1]
+    # Show original evidence, not the draft's classifications: the reviewer
+    # 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})
+
+
+def expand_maintenance(raw: str, context, *, diagnostics=None) -> str:
+    value = parse_strict_json(raw)
+    original, incoming, catalog = context
+    # Older host adapters can still provide fully bound compact output.
+    if isinstance(value, dict) and set(value) == {'memories','no_memory','deferred'}:
+        return raw
+    if not isinstance(value, dict) or set(value) != {'memories','discard','deferred'}:
+        raise _invalid()
+    if any(not isinstance(v,list) for v in value.values()):
+        raise _invalid()
+    seen = set()
+    reviewed_evidence = set()
+    def resolve(refs):
+        if not isinstance(refs,list) or not refs:
+            raise _invalid('invalid_evidence')
+        normalized = []
+        for ref in refs:
+            r = ref[1:] if isinstance(ref, str) and ref.startswith('d') else ref
+            normalized.append(int(r) if isinstance(r, str) and len(r) <= 20 and r.isascii() and r.isdecimal() else r)
+        if any((type(r) is not int and not isinstance(r, str)) or r not in incoming for r in normalized):
+            raise _invalid('invalid_evidence')
+        seen.update(normalized)
+        return [incoming[r] for r in normalized]
+    result = {'memories':[], 'no_memory':list(original['no_memory']), 'deferred':list(original['deferred'])}
+    # Only a genuine split may shed a previously bound update identity. A
+    # missing/null field in a one-to-one maintenance result is not a CREATE.
+    from_uses = {}
+    for proposed in value['memories']:
+        if isinstance(proposed, dict) and isinstance(proposed.get('from'), list):
+            for ref in proposed['from']:
+                key = str(ref).removeprefix('d')
+                from_uses[key] = from_uses.get(key, 0) + 1
+    def compile_row(row):
+        if isinstance(row, dict):
+            row = {'target': None, **row}
+        if isinstance(row, dict) and 'scopes' in row:
+            row = dict(row)
+            scopes_value = row.pop('scopes')
+            if not isinstance(scopes_value, list) or len(scopes_value) != 1 or ('scope' in row and row['scope'] != scopes_value[0]):
+                raise _invalid('invalid_scope')
+            row['scope'] = scopes_value[0]
+        if not isinstance(row,dict) or 'target' not in row or not {'from','title','body'} <= set(row):
+            raise _invalid()
+        if row['from'] == []:
+            # A catalog echo without fresh evidence cannot authorize a write.
+            # Ignore it only when every supplied field is literally unchanged.
+            target = row['target']
+            record = catalog.get(target.casefold()) if isinstance(target, str) else None
+            fields = {k: v for k, v in row.items() if k not in {'from', 'target'} and v is not None}
+            if record is None or any(record.get(k) != v for k, v in fields.items()):
+                raise _invalid('invalid_evidence')
+            return None
+        if set(row) - {'from', 'target', 'title', 'body', 'scope', 'type', 'status', 'due_date', 'completed_at', 'evidence'}:
+            raise _invalid()
+        if any(not isinstance(row[k], str) or not row[k].strip() for k in ('title', 'body')):
+            raise _invalid()
+        sources = resolve(row['from'])
+        scopes = {s['scope'] for s in sources}
+        if len(scopes)!=1 and 'scope' not in row:
+            raise _invalid('scope_drift')
+        scope = row.get('scope', next(iter(scopes)))
+        if not isinstance(scope, str) or not scope:
+            raise _invalid('invalid_scope')
+        kinds = {s.get('type', 'fact') for s in sources}
+        kind = row.get('type', next(iter(kinds)))
+        target = row['target']
+        inherited = {source['target'] for source in sources if isinstance(source.get('target'), str) and source['target'].casefold() in catalog}
+        if target is None and len(inherited) > 1:
+            raise _invalid('duplicate_update_target')
+        if target is None and len(inherited) == 1 and all(from_uses.get(str(ref).removeprefix('d')) == 1 for ref in row['from']):
+            target = next(iter(inherited))
+        if target is not None:
+            record = catalog.get(target.casefold()) if isinstance(target,str) else None
+            explicit_target = any(str(source.get('target', '')).casefold() == str(target).casefold() for source in sources)
+            if record is None or (record['scopes'] != [scope] and not (explicit_target or row.get('scope') == scope)):
+                raise _invalid('scope_drift')
+            if row.get('type') == 'todo' and record['type'] != 'todo':
+                raise _invalid('invalid_type')
+            kind = record['type']
+            if kind == 'todo' and 'todo' not in kinds and row.get('status') not in {'active', 'completed', 'cancelled'}:
+                raise _invalid('todo_fields')
+        elif len(kinds) != 1 and 'type' not in row:
+            raise _invalid('invalid_type')
+        if not isinstance(kind, str) or kind not in {'fact', 'preference', 'project', 'todo', 'event', 'identity', 'other'}:
+            raise _invalid('invalid_type')
+        memory = {k:v for k,v in row.items() if k!='from'}
+        memory['target']=target
+        memory['scope']=scope
+        memory['type']=kind
+        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))
+        bases = list(dict.fromkeys(int(r) for s in sources for r in (s.get('task_basis') or [])))
+        if bases and kind == 'todo':
+            memory['task_basis']=[ref for ref in bases if ref in chosen]
+            if not memory['task_basis']:
+                del memory['task_basis']
+        reviewed_evidence.update(allowed)
+        return memory
+
+    for index, row in enumerate(value['memories'], 1):
+        try:
+            memory = compile_row(row)
+            if memory is not None:
+                result['memories'].append(memory)
+        except ModelOutputError as error:
+            refs = row.get('from') if isinstance(row, dict) else None
+            try:
+                sources = resolve(refs)
+            except ModelOutputError:
+                # Unresolvable references cannot authorize any write. Missing
+                # input coverage is deferred below, independently of valid rows.
+                sources = []
+            evidence = list(dict.fromkeys(int(r) for source in sources for r in source['evidence']))
+            result['deferred'].extend(evidence)
+            if diagnostics is not None:
+                diagnostics.append({'row': index, 'detail': error.validation_detail, 'evidence': evidence})
+    for key,dest in (('discard','no_memory'),('deferred','deferred')):
+        if value[key]:
+            try:
+                refs = []
+                for entry in value[key]:
+                    if isinstance(entry, dict) and set(entry) <= {'from', 'reason'} and isinstance(entry.get('from'), list):
+                        refs.extend(entry['from'])
+                    else:
+                        refs.append(entry)
+                sources = resolve(refs)
+            except ModelOutputError:
+                sources = []
+            for row in sources:
+                result[dest].extend(row['evidence'])
+    for ref in set(incoming) - seen:
+        evidence = incoming[ref]['evidence']
+        result['deferred'].extend(evidence)
+        if diagnostics is not None:
+            diagnostics.append({'detail': 'invalid_evidence', 'evidence': evidence})
+    claimed = {ref for memory in result['memories'] for ref in memory['evidence']}
+    result['no_memory'].extend(sorted(reviewed_evidence - claimed - set(result['deferred'])))
+    for key in ('no_memory','deferred'):
+        result[key]=list(dict.fromkeys(int(r) for r in result[key]))
+    return json.dumps(result,ensure_ascii=False)

{memleaf-0.2.63 → 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_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。同一段的独立主题分别提炼。
-新 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或复制原文。'''
 
 
@@ -196,15 +196,6 @@ def _independent_project_subjects(text: str, scope_registry: Mapping[str, Any] |
     registry = scope_registry if isinstance(scope_registry, Mapping) else {}
     labels: set[str] = set()
     subjects: set[str] = set()
-    # Chinese project short forms have no word boundary. A unique leading
-    # name prefix can flag a separately headed clause without registering an
-    # invented alias. Ambiguous prefixes remain unresolved.
-    names = {scope: scope.partition(":")[2] for scope in registry if scope.startswith("project:")}
-    short_names = {}
-    for scope, name in names.items():
-        if re.fullmatch(r"[\u4e00-\u9fff]{4,}", name):
-            short_names[scope] = [name[:n] for n in range(2, len(name))
-                                  if sum(other.startswith(name[:n]) for other in names.values()) == 1]
     for clause in re.split(r"[。！？!?；;，\n、]+", text):
         clause = clause.strip(" -*•0123456789.()（）")
         clause_labels = _explicit_project_scope_labels([clause], registry)
@@ -213,14 +204,12 @@ def _independent_project_subjects(text: str, scope_registry: Mapping[str, Any] |
         if len(clause_labels) == 1:
             labels.update(clause_labels)
         matches = project_scope_matches_text(clause, {"scopes": registry})
-        matches = set(matches) | {scope for scope, terms in short_names.items()
-                                  if any(clause.startswith(term) for term in terms)}
         for scope in matches:
             node = registry.get(scope, {})
-            terms = [scope.partition(":")[2], *short_names.get(scope, [])]
+            terms = [scope.partition(":")[2]]
             if isinstance(node, Mapping):
                 terms += [v for v in node.get("aliases", []) if isinstance(v, str)]
-            if any(clause.casefold().startswith(term.casefold()) for term in terms if term):
+            if any(clause.casefold().startswith(term.casefold()) or re.search(r"(?:→|->|=>)\s*" + re.escape(term), clause, re.I) for term in terms if term):
                 subjects.add(scope)
     return labels | subjects
 
@@ -228,8 +217,8 @@ 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]}。
-每个独立主题单独列出，scope 表示主题真正所属的主体，按语义判断，不要求名称与证据逐字一致；没有明确主体才写 global。其他合法 scope：domain:名称、portfolio:名称、unscoped。
+返回 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 表示语义无法确定。覆盖所有片段，每个被一个或多个主题引用或列入一个数组。'''