memleaf 0.2.62__tar.gz → 0.2.64__tar.gz

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

@@ -2,6 +2,20 @@
 
 All notable changes to memleaf are documented here.
 
+## 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.
+- Keep maintenance complementary to extraction: it applies the same value judgment to incoming candidates, continues maintaining candidates that qualify, discards those without clear value and defers only unresolved meaning. The `0.2.62` date/ownership degradation and update-target grouping remain intact.
+
+Verification covers prompt consistency and compactness assertions, Python 3.11 compilation/imports, package metadata consistency, a package wheel containing the Hermes provider resource, and `git diff --check`. Real-provider replay remains runtime acceptance after installation.
+
 ## 0.2.62 — 2026-09-16
 
 - Record conclusions, not process. The contract now opens with one precedence rule -- 只记结论: what the user chose, agreed to, or what happened; options, plans and drafts offered by the assistant are process even when they look like reusable knowledge. It replaces a genuine conflict between two earlier sentences: `reusable`/通用经验 invited storing the assistant's own outline, while the assistant-proposal clause forbade it, so the model decided by coin flip. The contradictory sentence about assistant suggestions never being a task basis is gone with it. Measured on the reproduced turn, the assistant's four-section outline was written in one of two runs before the change and in none of four runs after it.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.62
+Version: 0.2.64
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,8 +23,9 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.62。**
-> 自动提炼只记结论：用户选定的、答应的、已发生的事；助手给出的选项、方案和草稿属于过程，即使它们看起来像可复用的经验也不写成记忆。同一件事只写一次，避免同一条内容同时落成事实和待办。提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），B3 仅作为兼容读取格式保留。
+> **版本：0.2.64。**
+> 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
+> 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；属于待办主题或预期结果的日期不会被误作截止日。项目归属由模型按语义判断，不要求项目名在证据里逐字出现。复核阶段会保留首轮已选定的更新目标，避免“状态变更”被降级成新增记忆。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。

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

@@ -4,8 +4,9 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.62.**
-> Automatic extraction now records conclusions only: what the user chose, agreed to, or what happened. Options, plans and drafts offered by the assistant are process, even when they look like reusable knowledge. One topic is written once, so the same content no longer lands as both a fact and a todo. A single Chinese semantic contract is now sent; the older English B3 prompt has been deleted and B3 remains only as a compatibility read format.
+> **Version: 0.2.64.**
+> 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.
 > A todo's `due_date` means only the explicit deadline of the todo action; dates describing its subject or desired outcome are not deadlines. Project ownership remains the model's semantic judgement and needs no literal name match. The review stage now keeps the update target chosen by the first pass, so a state change is no longer downgraded into a new memory. Markdown remains the sole source of truth.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.

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

@@ -4,8 +4,9 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.62。**
-> 自动提炼只记结论：用户选定的、答应的、已发生的事；助手给出的选项、方案和草稿属于过程，即使它们看起来像可复用的经验也不写成记忆。同一件事只写一次，避免同一条内容同时落成事实和待办。提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），B3 仅作为兼容读取格式保留。
+> **版本：0.2.64。**
+> 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
+> 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；属于待办主题或预期结果的日期不会被误作截止日。项目归属由模型按语义判断，不要求项目名在证据里逐字出现。复核阶段会保留首轮已选定的更新目标，避免“状态变更”被降级成新增记忆。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。

{memleaf-0.2.62 → memleaf-0.2.64}/docs/semantic-extraction-protocol.md

@@ -13,11 +13,9 @@
 
 ## 提炼判据
 
-契约只说我们要什么，不列禁止项：
+契约引导模型先判断信息是否有长期记忆价值，而不按具体业务场景列禁止项：综合未来复用、信息增量、再次读取时的直接可用性和忘记成本。只有对未来理解、判断或行动可能产生实质影响的信息才保留；没有明确价值就列入 `no_memory`，并只写产生该价值的最小核心。同一件事只写一次。
 
-- **只记结论**：用户选定的、答应的、已发生的事。助手给出的选项、方案、草稿属于过程——即使它看起来像可复用的通用经验，也仍然是过程。来源优先于"像不像经验"。
-- **同一件事只写一次**：同一条内容不会同时落成事实和待办。
-- `retention` 与类型独立：`reusable` 表示今后仍需使用的业务状态、约定或可复用结论；`session` 表示仅说明本轮如何查询、执行和恢复的过程，Core 会把它转成 `no_memory`。
+首轮提炼、主题选择、候选修复和 `semantic_maintenance` 共用这条判断标准。`retention` 与类型独立：`reusable` 表示符合上述标准，`session` 表示不符合，Core 会把 `session` 转成 `no_memory`。维护阶段将符合标准的 incoming 继续维护，不符合的丢弃，语义无法确定的延后；它负责维护已有候选，不重新发明主题。
 
 ## 降级而不是丢弃
 

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

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

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

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

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

{memleaf-0.2.62 → memleaf-0.2.64}/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.62 → memleaf-0.2.64}/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,
 )

memleaf-0.2.64/src/memleaf/semantic_maintenance.py

@@ -0,0 +1,179 @@
+"""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 仅划定待复核的主题，不提供已确认的分类或归属。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 只能选输入中已有的编号。'''
+
+
+def maintenance_input(raw: str, fragments: list[dict[str, Any]], catalog: list[dict[str, Any]], model_data: Mapping[str, Any]):
+    # 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}
+    for index, row in enumerate(original['memories'], 1):
+        incoming[index] = dict(row)
+        proposal = {'id': f'd{index}', 'evidence': row['evidence']}
+        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}
+    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)
+        allowed = list(dict.fromkeys(int(r) for s in sources for r in s['evidence']))
+        chosen = row.get('evidence', allowed)
+        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.62 → memleaf-0.2.64}/src/memleaf/semantic_protocol.py

@@ -107,16 +107,15 @@ def source_fragments(b3_prompt: str) -> dict[str, Any]:
             'scope_context': data['scope_background'], 'scope_registry': data['scope_registry']}
 
 
-RETENTION_GUIDANCE = """retention 独立于 fact/todo 类型：reusable 表示今后仍需使用的业务状态、约定、稳定环境或可复用结论；session 表示仅说明本轮如何查询、执行和恢复的过程及瞬时结果。一次操作成功或失败不自动建立稳定结论；若已明确形成持续问题、后续任务或通用经验，保留其成立的核心含义。session 由 Core 转为 no_memory，不写入长期记忆。"""
+RETENTION_GUIDANCE = """长期记忆服务于未来协作，不是业务流水归档。保留持续事项的行动与状态、稳定偏好及可直接复用的知识；仅供本次查阅知悉的通知、过程记录不保留。事实成立或能想象用途并不足够，未来仍须重新查询来源才可信的信息通常不保留。只留下有明确未来用途的最小核心，无此价值放 no_memory；已有事项的状态变化仍须更新。retention=reusable 表示可复用，session 表示仅本轮有用。"""
 
 
-FRAGMENT_SYSTEM = f'''只记结论：用户选定的、答应的、已发生的事。助手给的选项、方案、草稿是过程，哪怕它看起来像通用经验，也仍然是过程。
-根据底层长期有效的业务含义提炼记忆，不继承原文的标题、紧急程度、列表分类或建议处理方式。
+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 写这条事实归属的那个主体的名字，形如 project:鑫元基金——客户、项目、系统、产品都算，证据里出现了谁就写谁；只有整条确实没有主体时才写 global。同一段的独立主题分别提炼。
+每条 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 解析相对日期。
-no_memory 填仅服务本轮交互、没有后续使用价值的片段ID；deferred 填语义尚无法确定的片段ID。每个片段须被 memory 引用或列入其中一个数组。同片段允许支持多条 memory。若为 catalog 中同一事项的补充、状态变化或重复，target 填已有真实 ID 并给出合并后的当前内容；新事项才省略 target。无需输出写入决策、生成ID或复制原文。'''
+no_memory 填不符合上述长期记忆价值标准的片段ID；deferred 填语义尚无法确定的片段ID。每个片段须被 memory 引用或列入其中一个数组。同片段允许支持多条 memory。若为 catalog 中同一事项的补充、状态变化或重复，target 填已有真实 ID 并给出合并后的当前内容；新事项才省略 target。无需输出写入决策、生成ID或复制原文。'''
 
 
 def expand_fragments(raw: str, fragments: list[dict[str, Any]]) -> str:
@@ -197,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)
@@ -214,24 +204,22 @@ 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
 
 
 
-TOPIC_SYSTEM = RETENTION_GUIDANCE + "\n" + '''根据底层长期有效的业务含义识别值得保留的独立主题，不继承原文标题、紧急程度、列表分类或建议处理方式。
+TOPIC_SYSTEM = RETENTION_GUIDANCE + "\n" + '''根据对话语义识别值得保留的独立主题，不继承原文标题、紧急程度、列表分类或建议处理方式。
 这一阶段只选择有后续价值的主题及其证据，不写记忆正文，不分类，不处理日期，不决定数据库操作。
 返回 JSON {"topics":[{"retention":"reusable 或 session","scope":"project:项目名 或 global","evidence":[片段ID]}],"no_memory":[片段ID],"deferred":[片段ID]}。
-每个独立主题单独列出，scope 表示主题真正所属的项目，系统/工具名不自动成为归属。其他合法 scope：domain:名称、portfolio:名称、unscoped。
-no_memory 表示仅服务本轮交互的操作过程或瞬时信息，没有长期业务含义；deferred 表示语义无法确定。覆盖所有片段，每个被一个或多个主题引用或列入一个数组。'''
+每个独立主题单独列出，scope 表示主题真正所属的主体，按语义判断，不要求名称与证据逐字一致；通用原则写 global，主体所属项目尚未确认写 unscoped，不根据名称相似或当前项目猜测。其他合法 scope：domain:名称、portfolio:名称、unscoped。
+no_memory 表示不符合上述长期记忆价值标准；deferred 表示语义无法确定。覆盖所有片段，每个被一个或多个主题引用或列入一个数组。'''
 
 
 def compile_topics(raw: str, fragments: list[dict[str, Any]], protocol_version: str, *, contexts=None):