memleaf 0.2.59__tar.gz → 0.2.61__tar.gz

{memleaf-0.2.59 → memleaf-0.2.61}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.61 — 2026-09-15
+
+- Split ordinary automatic extraction into a model-facing semantic protocol and a Core-owned B3 write protocol. Core supplies short immutable evidence-fragment IDs and binds their original spans locally; the model first selects reusable topics and then synthesizes memory content. Core compiles the result into B3 candidate IDs, decisions, evidence, targets and write fields before the existing validators and commit path run.
+- Separate retention from memory type with `reusable` and `session`. Transient execution, lookup and recovery details can settle as `no_memory`, while a durable failure, business fact or follow-up task remains eligible when its underlying meaning has future value. Coverage stays fail-closed, user tasks require explicit user assertion evidence, and a local target cannot be guessed into a CREATE or NO_CHANGE.
+- Raise the durable automatic request budget to three: topic selection and synthesis use two requests, while candidate repair or same-target coordination shares one final request. Candidate-level repair can correct date/ownership/value disagreements without rewriting valid siblings; project-subject guards and bounded date diagnostics remain Core-owned and never persist arbitrary model or error text.
+
+Verification for this release used 58 local synthetic regression tests with no model call or production Vault write (35 semantic-protocol tests and 23 existing extraction-boundary tests). Python 3.11 compilation/imports, `git diff --check` and a package wheel containing the Hermes provider resource pass. Real-provider quality, latency and a newly installed Hermes replay remain separate runtime acceptance.
+
+## 0.2.60 — 2026-09-15
+
+- Tighten the B3 planner's output discipline without changing its protocol or write semantics. The system prompt now says not to analyze beyond the task, decide directly and return promptly, and keep each memory as brief as possible without losing essential meaning. Evidence, Scope, date grounding, candidate decisions and commit safety remain unchanged.
+- Treat the prompt change as a bounded efficiency-oriented instruction, not a measured latency claim; provider behavior and model quality remain runtime-dependent.
+
+Verification for this release used 23 focused local regression tests with no model call and no production Vault write. Python 3.11 compilation/imports and `git diff --check` pass; real-provider latency and adherence remain unmeasured, and a newly installed Hermes replay remains post-release runtime acceptance.
+
 ## 0.2.59 — 2026-09-15
 
 - Simplify the B3 planner prompt around ordinary semantic judgment. The system instruction is now under 3 KiB and avoids scenario-specific rules; it asks the model to keep only future-use information, identify the user's exact unfinished action before classifying a todo, and attach a date only when that action is explicitly due by it.

{memleaf-0.2.59/src/memleaf.egg-info → memleaf-0.2.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.59
+Version: 0.2.61
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,9 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.59。**
+> **版本：0.2.61。**
+> 普通自动提炼改为“主题选择 → 内容提炼”的语义协议，模型只引用 Core 提供的短证据片段；Core 继续编译并校验内部 B3 写入协议。临时执行过程可标记为 `session` 而不写入长期记忆，正常路径两次模型调用，候选修复与同目标协调共享第三次预算。
+> B3 提取提示要求模型只聚焦当前任务、直接返回并保持记忆简短，减少无关分析和冗长输出；证据、Scope、日期和写入规则不变。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；Core 不再从候选证据中的其他日期自动补填。属于待办主题或预期结果的日期不会被误作截止日，无法确认动作截止日时就省略。
 > 自动提取按助手回复中的 Markdown 结构建立候选级来源，过宽的整段引用和未被用户接受的助手意图不会形成记忆。项目归属由模型按语义判断，不再要求项目名在证据里逐字出现：同一个项目换个说法也能落到已有 Scope 上，名字也不再决定这条记忆的生死。日期和截止日期使用统一的边界安全解析，todo 只在候选自己的证据给出唯一明确截止日时填充。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。

{memleaf-0.2.59 → memleaf-0.2.61}/README.en.md

@@ -4,7 +4,9 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.59.**
+> **Version: 0.2.61.**
+> Ordinary automatic extraction now uses a “topic selection → content synthesis” semantic protocol. The model cites only short evidence fragments supplied by Core, while Core still compiles and validates the internal B3 write contract. Transient execution can be marked `session` without entering long-term memory; the normal path uses two model requests, with candidate repair and same-target coordination sharing a third budget.
+> The B3 extraction prompt now tells the model to focus only on the task, decide directly, return promptly, and keep memories brief; evidence, Scope, date and write semantics are unchanged.
 > A todo's `due_date` now means only the explicit deadline of the todo action. Core no longer fills it from other dates in candidate evidence; dates describing the todo's subject or desired outcome are not deadlines, and an unconfirmed action deadline is omitted.
 > Automatic extraction now creates candidate-local source units from Markdown structure in assistant replies; broad whole-report citations and assistant-only intent are not allowed to create memories. Project ownership is the model's semantic judgement and no longer requires the project name to appear literally in the evidence: one project referred to in different words lands on the existing Scope, and the name no longer decides whether the memory survives. Dates and deadlines use one boundary-safe parser, and a todo receives a due date only when its own evidence supplies one unambiguous deadline. Markdown remains the sole source of truth with no SQLite runtime dependency. Acceptance covers deterministic regression suites and synthetic inputs; it does not claim real-mail or customer-business acceptance.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.

{memleaf-0.2.59 → memleaf-0.2.61}/README.md

@@ -4,7 +4,9 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.59。**
+> **版本：0.2.61。**
+> 普通自动提炼改为“主题选择 → 内容提炼”的语义协议，模型只引用 Core 提供的短证据片段；Core 继续编译并校验内部 B3 写入协议。临时执行过程可标记为 `session` 而不写入长期记忆，正常路径两次模型调用，候选修复与同目标协调共享第三次预算。
+> B3 提取提示要求模型只聚焦当前任务、直接返回并保持记忆简短，减少无关分析和冗长输出；证据、Scope、日期和写入规则不变。
 > 待办 `due_date` 只表示待办动作本身明确声明的截止日；Core 不再从候选证据中的其他日期自动补填。属于待办主题或预期结果的日期不会被误作截止日，无法确认动作截止日时就省略。
 > 自动提取按助手回复中的 Markdown 结构建立候选级来源，过宽的整段引用和未被用户接受的助手意图不会形成记忆。项目归属由模型按语义判断，不再要求项目名在证据里逐字出现：同一个项目换个说法也能落到已有 Scope 上，名字也不再决定这条记忆的生死。日期和截止日期使用统一的边界安全解析，todo 只在候选自己的证据给出唯一明确截止日时填充。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。

{memleaf-0.2.59 → memleaf-0.2.61}/docs/extraction-latency.md

@@ -19,7 +19,7 @@ llm:
 
 ## 保留的调用与提交约束
 
-普通 B3 自动提炼仍以一次结构化模型调用为正常路径，格式/结构修复最多一次。固定安全路由保留实际 outbound 请求计数和持久化预占，不增加隐藏 host-to-API fallback。并未恢复 Gate → Summary → Review 多阶段主路径。
+普通自动提炼分为主题选择和内容提炼，正常使用两次模型调用，全部遵循 `single_pass` 思考配置（默认 `disabled`），包括候选修复。B3 是 Core 内部写入协议。候选校验失败时允许一次局部修复；结构修复和同目标协调共享总计三次的请求上限。固定安全路由保留实际 outbound 请求计数和持久化预占，不增加隐藏 host-to-API fallback。语义质量和耗时分别验收。
 
 每轮仍先读取持久状态、规划、校验、提交，再处理下一轮；一轮超过目标不会占用下一轮的“时间许可”。compaction 仍不在普通提炼的关键路径上。
 

memleaf-0.2.61/docs/semantic-extraction-protocol.md

@@ -0,0 +1,33 @@
+# 自动记忆提炼：语义协议与 Core 写入协议
+
+普通自动提炼保留 B3 作为内部写入协议，模型不再同时生成完整 B3 决策、候选 ID、精确引文、覆盖原因和正文。
+
+## 正常路径
+
+1. **Core 建立证据片段**：按通用标点和换行生成短编号，保留原始 unit、字符位置、角色和时间锚点。模型只引用编号；原文和偏移由 Core 绑定。
+2. **主题选择**：使用 `single_pass` 配置（当前关闭思考），仅判断长期价值、独立主题及归属，返回 `topics / no_memory / deferred`。
+3. **内容提炼**：使用 `single_pass` 配置（当前关闭思考），从完整证据独立生成内容，并复核主题选择阶段的 no_memory，防止第一阶段的遗漏变成假完整。业务事实默认 `fact`；新 Todo 必须提供用户陈述中的任务依据。上一轮候选正文不作为新证据。
+4. **Core 编译与校验**：生成 B3 候选 ID、写入决策和覆盖原因，验证所有引用、目标、字段、日期与归属；之后使用原有提交和恢复机制。
+
+两个阶段均依据底层长期含义重新判断，不继承源对话的标题、紧急程度或建议处理方式。语义协议不包含客户、产品或项目名单。
+
+## 容错与保护
+
+- 缺失或未知片段不会自动变成 `no_memory`。片段覆盖必须完整；同一原始 unit 内存在未解决主题时仍保留未完成状态。
+- 模型无需复制 Markdown 或计算 Unicode 偏移，也不需要根据记录时间推算正文日期。日期保持原文形式，Core 仅以候选已引用的证据解析相对日期和明确截止日期。
+- 新 Todo 必须绑定 `user_assertion`。他方请求可建立业务事实，助手建议和用户查询不能单独建立用户任务。已有 Todo 仍通过真实目录目标维护。
+- `target` 只能引用当前目录。无效目标限制在候选内，不会猜成 CREATE；只有完整已知内容相同才由 Core 生成 NO_CHANGE。
+- 已注册或当前计划中出现的项目，在正文不同分句中作为独立主语出现时，Core 拒绝合并写入。显式项目标签也可建立此冲突。仅在一个关系句中提及两个项目，不自动视为独立主题。未知实体的语义识别仍由模型完成，此保护不是任意文本的完备分类器。
+- 校验失败或两阶段对长期价值存在分歧时，允许一次候选级修复或裁决：提供原始证据和具体违规信息，重新提炼并再次校验，保留已成立核心事实。不会机械删除一句可能改变原意的文本；有效兄弟候选不重写。
+- 正常两次请求，修复或同目标协调共享第三次额度。计数在后台持久化预占，重启不清零；最终仍无法验证的候选继续 DEFERRED，不伪装 complete。
+- 拒绝日期时记录 allowlist 字段名和受限日期字面值。可选模型诊断与最终拒绝候选的审计保留这些信息，不保存任意错误正文、凭证或完整拒绝句子。
+
+## 验证边界
+
+本地测试覆盖引用与覆盖、真正/虚假目标、用户任务依据、日期修复、跨项目污染、合法关系句、修复失败及持久预算。真实模型验收另在隔离 Vault 中执行。十秒目标仍只是性能观测，不能用局部测试或一次成功重放宣称所有语义场景已通过。
+
+### 保留价值与内容类型分离
+
+主题和记忆候选支持 `retention: reusable | session`。模型判断内容是在描述本轮执行过程，还是已经成立的可复用状态、经验或后续事项；不根据工具名、错误码或来源角色做过滤。Core 将 `session` 引用转换为 `no_memory`，不产生写入候选；同一证据单元中其他可保留片段继续独立处理。旧适配器省略该字段时保持原有行为。语义判断仍可能出错，此字段不是确定性内容分类器。
+
+关闭思考的目标会话重放中，临时读取故障经局部复核标记为 `session`，未写入隔离记忆库。整体覆盖仍为 partial，原因是其他候选校验；本次仅验收临时执行信息过滤。

{memleaf-0.2.59 → memleaf-0.2.61}/pyproject.toml

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

{memleaf-0.2.59 → memleaf-0.2.61}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.59"
+__version__ = "0.2.61"
 
 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.59 → memleaf-0.2.61}/src/memleaf/extraction_budget.py

@@ -13,20 +13,20 @@ from typing import Any, Iterable, Mapping
 from .llm import ModelError
 
 
-MAX_MODEL_REQUESTS = 2
+MAX_MODEL_REQUESTS = 3
 TARGET_TOTAL_SECONDS = 10.0
 
 
 class SinglePassBudgetBackend:
-    """Limit one logical B3 turn to two actual provider requests.
+    """Limit topic selection, synthesis and optional candidate repair to three requests.
 
     ``single_pass_safe`` routes map one complete() call to one request, without
     hidden host-to-API fallback. The optional durable reservation preserves
     consumed attempts across worker restarts. Neither the first request nor
     its repair overrides the transport's configured ``llm.request_timeout``.
-    The second request is spent on whichever bounded follow-up the planner
-    actually needs -- a structural repair or a same-target reconciliation --
-    so a collision between two admitted items can never extend the turn.
+    Topic selection and synthesis use two requests. One remaining request
+    covers candidate correction or same-target reconciliation. Competing
+    follow-ups share that budget; they cannot extend it.
     """
 
     def __init__(

{memleaf-0.2.59 → memleaf-0.2.61}/src/memleaf/extraction_work_state.py

@@ -3,7 +3,7 @@
 A detached worker can die after a provider request but before memleaf records a
 normal model failure.  The process-job ID survives that worker restart, so use
 it as the stable work identity and reserve each outbound single-pass request
-*before* dispatch.  A restarted worker therefore cannot reopen the two-call
+*before* dispatch.  A restarted worker therefore cannot reopen the bounded
 automatic budget for the same turn.
 
 Older releases also recorded a wall-clock start. Those timestamps are accepted
@@ -22,6 +22,7 @@ from pathlib import Path
 from typing import Any, Mapping
 
 from .locking import atomic_write_json, read_json
+from .extraction_budget import MAX_MODEL_REQUESTS
 
 
 _VERSION = 1
@@ -74,13 +75,13 @@ def _normalize_turn_state(value: Any) -> dict[str, Any]:
     compatibility only; no request ordinal is reset and no expiry is inferred.
     """
 
-    if type(value) is int and 0 <= value <= 2:
+    if type(value) is int and 0 <= value <= MAX_MODEL_REQUESTS:
         return {"requests": value, "started_at_epoch": None}
     if not isinstance(value, Mapping):
         raise ExtractionWorkStateError("invalid extraction request budget counter")
     requests = value.get("requests")
     started = value.get("started_at_epoch")
-    if type(requests) is not int or not 0 <= requests <= 2:
+    if type(requests) is not int or not 0 <= requests <= MAX_MODEL_REQUESTS:
         raise ExtractionWorkStateError("invalid extraction request budget counter")
     if started is not None and not _valid_epoch(started):
         raise ExtractionWorkStateError("invalid extraction work start time")
@@ -213,9 +214,9 @@ def active_background_work_id(
 
 
 def reserve_model_request(vault: Any, *, work_id: str, turn_id: str) -> int | None:
-    """Atomically reserve the next provider request and return ordinal 1/2.
+    """Atomically reserve the next provider request and return its ordinal.
 
-    ``None`` means this stable work+turn already consumed both requests.  The
+    ``None`` means this stable work+turn already consumed the request budget.  The
     reservation happens before the outbound call, so a process kill after this
     write still consumes that attempt conservatively.
     """
@@ -240,7 +241,7 @@ def reserve_model_request(vault: Any, *, work_id: str, turn_id: str) -> int | No
             turn_state = _normalize_turn_state(turn_state)
             turns[turn_id] = turn_state
         count = turn_state["requests"]
-        if count >= 2:
+        if count >= MAX_MODEL_REQUESTS:
             return None
         ordinal = count + 1
         turn_state["requests"] = ordinal

{memleaf-0.2.59 → memleaf-0.2.61}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.59 → memleaf-0.2.61}/src/memleaf/model_execution.py

@@ -802,6 +802,10 @@ class ModelExecutor:
             "validation_detail": validation_detail,
             **_model_output_statistics(raw, purpose),
         }
+        date_info = getattr(error, "date_diagnostics", None)
+        if isinstance(date_info, Mapping):
+            from .validation import safe_date_diagnostics
+            entry.update(safe_date_diagnostics(date_info))
         if evidence_check is not None:
             entry["evidence_check"] = evidence_check
         entry.update(_safe_evidence_diagnostics(error) if error is not None else {})

memleaf-0.2.61/src/memleaf/semantic_protocol.py

@@ -0,0 +1,237 @@
+"""Small model-facing extraction contract; B3 remains the Core write contract.
+
+IDs, decisions, evidence roles and coverage reasons are compiled locally. Missing
+coverage is never interpreted as no-memory. All resulting claims still pass the
+existing admission and memory validators before any write.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Mapping
+
+from .validation import MEMORY_TYPES, ModelOutputError, parse_strict_json
+
+
+def _invalid(detail: str = 'other_schema_violation') -> ModelOutputError:
+    return ModelOutputError('invalid semantic extraction contract', validation_detail=detail)
+
+
+def compile_semantic(raw: str, *, protocol_version: str, local_by_key: Mapping[str, Any],
+                     prefix: str = 'c') -> tuple[dict[str, Any], dict[str, Any]]:
+    value = parse_strict_json(raw)
+    if not isinstance(value, dict) or set(value) != {'memories', 'no_memory', 'deferred'}:
+        raise _invalid()
+    if any(not isinstance(value[k], list) for k in value):
+        raise _invalid()
+    items, bases = [], {}
+    required = {'title', 'body', 'scope', 'evidence'}
+    optional = {'type', 'target', 'task_basis', 'due_date', 'status', 'completed_at'}
+    for i, row in enumerate(value['memories']):
+        if not isinstance(row, dict) or not required <= set(row) or set(row) - required - optional:
+            raise _invalid()
+        row = {"type": "fact", **row}
+        if any(not isinstance(row[k], str) or not row[k].strip() for k in ('title', 'body', 'type', 'scope')):
+            raise _invalid()
+        if not isinstance(row['evidence'], list) or not row['evidence']:
+            raise _invalid('invalid_evidence')
+        claims = []
+        for claim in row['evidence']:
+            if (not isinstance(claim, dict) or not {'unit_id', 'quote'} <= set(claim)
+                    or set(claim) - {'unit_id', 'quote', 'start', 'end'}
+                    or any(not isinstance(claim[k], str) or not claim[k] for k in ('unit_id', 'quote'))):
+                raise _invalid('invalid_evidence')
+            claims.append({**claim, 'role': 'assertion'})
+        cid = f'{prefix}{i + 1}'
+        target = row.get('target')
+        if target is not None and (not isinstance(target, str) or target.casefold() not in local_by_key):
+            # Invalid targets remain candidate-local and cannot become CREATE.
+            items.append({'candidate_id': cid, 'decision': 'DEFERRED',
+                          'reason': 'target_ambiguous', 'evidence': claims})
+            continue
+        memory = {k: row[k] for k in ('title', 'body', 'due_date', 'status', 'completed_at') if k in row}
+        item = {'candidate_id': cid, 'evidence': claims, 'memory': memory}
+        if target is None:
+            item.update(decision='CREATE', type=row['type'], scopes=[row['scope']])
+        else:
+            record = local_by_key[target.casefold()]
+            # Semantic matches still use UPDATE and the normal Core validator;
+            # only literal equality can be compiled to NO_CHANGE here.
+            same = (row['type'] == record['type'] and [row['scope']] == record['scopes']
+                    and all(memory.get(k) == record.get(k) for k in memory)
+                    and all(record.get(k) is None or k in memory for k in ('status', 'completed_at', 'due_date')))
+            item.update(decision='NO_CHANGE' if same else 'UPDATE', target_memory_id=record['memory_id'])
+            if same:
+                del item['memory']
+            else:
+                item['scopes'] = [row['scope']]
+        if 'task_basis' in row:
+            basis = row['task_basis']
+            if (not isinstance(basis, dict) or set(basis) != {'unit_id', 'quote'}
+                    or any(not isinstance(v, str) or not v for v in basis.values())):
+                raise _invalid('invalid_evidence')
+            bases[cid] = basis
+        items.append(item)
+    for i, uid in enumerate(value['deferred']):
+        if not isinstance(uid, str) or not uid:
+            raise _invalid('invalid_evidence')
+        items.append({'candidate_id': f'{prefix}d{i + 1}', 'decision': 'DEFERRED',
+                      'reason': 'evidence_insufficient',
+                      'evidence': [{'unit_id': uid, 'whole_unit': True, 'role': 'assertion'}]})
+    if any(not isinstance(uid, str) or not uid for uid in value['no_memory']):
+        raise _invalid('invalid_evidence')
+    return {'protocol_version': protocol_version, 'items': items,
+            'no_memory': [{'unit_id': uid, 'reason': 'no_future_value'} for uid in value['no_memory']]}, bases
+
+
+def source_fragments(b3_prompt: str) -> dict[str, Any]:
+    """Assign short references to immutable source spans, not generated quotes."""
+    import re
+    data = json.loads(b3_prompt.removeprefix('B3_INPUT\n').removesuffix(
+        '\nReturn the complete strict B3 envelope.'))
+    fragments = []
+    for unit in data['current_evidence']:
+        text = unit['content']
+        matches = list(re.finditer(r'[^\n。！？!?；;]+[。！？!?；;]?', text))
+        if not matches and text.strip():
+            matches = [re.search(r'[\s\S]+', text)]
+        for match in matches:
+            if not match.group().strip():
+                continue
+            fragments.append({'id': len(fragments) + 1, 'unit_id': unit['unit_id'],
+                              'role': unit['role'], 'text': match.group(),
+                              'start': match.start(), 'end': match.end(),
+                              'context': unit.get('section_path', []),
+                              'timestamp': unit.get('timestamp')})
+    return {'fragments': fragments, 'catalog': data['local_memory_catalog'],
+            'scope_context': data['scope_background'], 'scope_registry': data['scope_registry']}
+
+
+RETENTION_GUIDANCE = """retention 独立于 fact/todo 类型：reusable 表示今后仍需使用的业务状态、约定、稳定环境或可复用结论；session 表示仅说明本轮如何查询、执行和恢复的过程及瞬时结果。一次操作成功或失败不自动建立稳定结论；若已明确形成持续问题、后续任务或通用经验，保留其成立的核心含义。session 由 Core 转为 no_memory，不写入长期记忆。"""
+
+
+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 是核心事实实际所属项目，不是报告该信息的系统。同一段的独立主题分别提炼；还支持 domain:名称、portfolio:名称、unscoped。
+新 todo 额外提供 task_basis:[用户角色片段ID]，其内容须明确建立用户自己承担的未完成动作；他方请求或助手建议本身是事实依据，不是用户任务依据。todo 可选 status（active/completed/cancelled）、completed_at、due_date（原文明确属于该动作的截止日期）。日期保留原文写法，由 Core 解析相对日期。
+no_memory 填仅服务本轮交互、没有后续使用价值的片段ID；deferred 填语义尚无法确定的片段ID。每个片段须被 memory 引用或列入其中一个数组。同片段允许支持多条 memory。若与 catalog 中已有记忆是同一主题，可填 target 为其真实 ID；否则省略。无需输出写入决策、生成ID或复制原文。'''
+
+
+def expand_fragments(raw: str, fragments: list[dict[str, Any]]) -> str:
+    """Bind short references exactly and compile fragment coverage to unit coverage."""
+    value = parse_strict_json(raw)
+    if not isinstance(value, dict) or set(value) != {'memories', 'no_memory', 'deferred'}:
+        raise _invalid()
+    if any(not isinstance(value[k], list) for k in value):
+        raise _invalid()
+    by_id = {f['id']: f for f in fragments}
+    seen = set()
+    claimed_units = set()
+    def resolve(ids):
+        if not isinstance(ids, list) or any(type(i) is not int or i not in by_id for i in ids):
+            raise _invalid('invalid_evidence')
+        seen.update(ids)
+        return [by_id[i] for i in ids]
+    rows = []
+    session_refs = []
+    for row in value['memories']:
+        if not isinstance(row, dict):
+            raise _invalid()
+        refs = resolve(row.get('evidence'))
+        if not refs:
+            raise _invalid('invalid_evidence')
+        retention = row.get('retention', 'reusable')
+        if retention not in ('reusable', 'session'):
+            raise _invalid()
+        if retention == 'session':
+            if 'task_basis' in row:
+                session_refs.extend(resolve(row['task_basis']))
+            session_refs.extend(refs)
+            continue
+        claimed_units.update(f['unit_id'] for f in refs)
+        row = {k: v for k, v in row.items() if k != 'retention'}
+        result = {**row, 'evidence': [{'unit_id': f['unit_id'], 'quote': f['text'], 'start': f['start'], 'end': f['end']} for f in refs]}
+        if 'task_basis' in row:
+            bases = resolve(row['task_basis'])
+            if not bases:
+                raise _invalid('invalid_evidence')
+            # Task basis is itself an explicit source citation. Bind it too.
+            for f in bases:
+                if f['id'] not in row['evidence']:
+                    result['evidence'].append({'unit_id': f['unit_id'], 'quote': f['text'], 'start': f['start'], 'end': f['end']})
+                    claimed_units.add(f['unit_id'])
+            # Keep one concrete admitted basis for the ownership reviewer.
+            result['task_basis'] = {'unit_id': bases[0]['unit_id'], 'quote': bases[0]['text']}
+        rows.append(result)
+    ignored = resolve(value['no_memory']) + session_refs
+    deferred = resolve(value['deferred'])
+    if seen != set(by_id):
+        raise _invalid('invalid_evidence')
+    deferred_units = {f['unit_id'] for f in deferred}
+    # A partial unit with an unresolved topic remains unresolved even if its
+    # other topic was retained. No-memory is terminal only for unclaimed units.
+    return json.dumps({'memories': rows,
+                       'no_memory': list(dict.fromkeys(f['unit_id'] for f in ignored
+                                         if f['unit_id'] not in claimed_units | deferred_units)),
+                       'deferred': list(dict.fromkeys(f['unit_id'] for f in deferred))}, ensure_ascii=False)
+
+def _independent_project_subjects(text: str, scope_registry: Mapping[str, Any] | None) -> set[str]:
+    """Conservative structural guard, not a project-name classifier.
+
+    Explicit labels and registered subjects in separate clauses are enough to
+    prove a multi-project aggregate. Merely mentioning a dependency/vendor in
+    one relational clause does not imply independent ownership.
+    """
+    import re
+    from .process_common import _explicit_project_scope_labels
+    from .scope_state import project_scope_matches_text
+    registry = scope_registry if isinstance(scope_registry, Mapping) else {}
+    labels: set[str] = set()
+    subjects: set[str] = set()
+    for clause in re.split(r"[。！？!?；;\n、]+", text):
+        clause = clause.strip(" -*•0123456789.()（）")
+        clause_labels = _explicit_project_scope_labels([clause], registry)
+        # Multiple names within one relationship clause are not proof of
+        # independent topics. Separate explicitly labelled clauses are.
+        if len(clause_labels) == 1:
+            labels.update(clause_labels)
+        matches = project_scope_matches_text(clause, {"scopes": registry})
+        for scope in matches:
+            node = registry.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):
+                subjects.add(scope)
+    return labels | subjects
+
+
+
+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 表示语义无法确定。覆盖所有片段，每个被一个或多个主题引用或列入一个数组。'''
+
+
+def compile_topics(raw: str, fragments: list[dict[str, Any]], protocol_version: str):
+    value = parse_strict_json(raw)
+    if not isinstance(value, dict) or set(value) != {'topics', 'no_memory', 'deferred'} or not isinstance(value['topics'], list):
+        raise _invalid()
+    rows = []
+    scopes = []
+    for topic in value['topics']:
+        if not isinstance(topic, dict) or not {'scope', 'evidence'} <= set(topic) or set(topic) - {'scope', 'evidence', 'retention'} or not isinstance(topic['scope'], str):
+            raise _invalid()
+        if topic.get('retention', 'reusable') != 'session':
+            scopes.append(topic['scope'])
+        rows.append({'title':'Pending topic','body':'Pending semantic extraction.', **topic})
+    expanded = expand_fragments(json.dumps({'memories':rows,'no_memory':value['no_memory'],
+                                           'deferred':value['deferred']}), fragments)
+    envelope, _ = compile_semantic(expanded,protocol_version=protocol_version,local_by_key={})
+    for item in envelope['items']:
+        if item['decision']=='CREATE':
+            for key in ('type','scopes','memory'):
+                item.pop(key,None)
+            item.update(decision='DEFERRED',reason='maintenance_uncertain')
+    return envelope, scopes

{memleaf-0.2.59 → memleaf-0.2.61}/src/memleaf/single_pass_memory_planner.py

@@ -1,9 +1,7 @@
 """Production-shaped automatic planner for the B3 single-pass experiment.
 
 This class intentionally reuses the existing MemoryPlanner request identity,
-retry ledger, Core validation and writer contracts while replacing the normal
-automatic Gate -> reconciliation -> Summary -> semantic-review chain with one
-semantic model call. Explicit remember remains delegated until its dedicated
+retry ledger, Core validation and writer contracts while compiling a compact topic-selection and synthesis protocol into B3. Explicit remember remains delegated until its dedicated
 B3 contract is validated.
 """
 from __future__ import annotations
@@ -34,8 +32,9 @@ from .process_common import (
 )
 from .single_pass_plan import run_single_pass_stage
 from .turn_plan import dedup_digest, revision_digest
-from .validation import ModelOutputError, parse_summarize_output
+from .validation import ModelOutputError, parse_summarize_output, calendar_tokens
 from .evidence_syntax import _assistant_intent_only
+from .semantic_protocol import _independent_project_subjects
 from .llm import ModelUnavailable
 
 
@@ -108,7 +107,7 @@ def _global_scope_conflicts_with_candidate_evidence(
 
 
 class SinglePassMemoryPlanner(MemoryPlanner):
-    """One semantic model call for an ordinary automatic turn."""
+    """Bounded topic selection and synthesis for an ordinary automatic turn."""
 
     @staticmethod
     def _fallback_scopes(scope_background: Any) -> tuple[list[str], str]:
@@ -511,6 +510,12 @@ class SinglePassMemoryPlanner(MemoryPlanner):
             if decision == "UPDATE" and isinstance(target_id, str):
                 candidate["update_memory_id"] = target_id
 
+            subjects = _independent_project_subjects(str(proposed.get("body", "")), validation_scope_registry)
+            if len(subjects) > 1:
+                raise ModelOutputError(
+                    "memory combines independently owned project subjects",
+                    validation_detail="scope_drift",
+                )
             candidate_evidence = _claim_date_evidence(claims, by_unit, events)
             if _global_scope_conflicts_with_candidate_evidence(
                 scopes, candidate_evidence, by_unit, validation_scope_registry
@@ -569,6 +574,13 @@ class SinglePassMemoryPlanner(MemoryPlanner):
             deadline_dates = _grounded_deadline_dates(candidate_date_evidence)
             grounded_dates.update(deadline_dates)
             summary = dict(proposed)
+            # The model need not calculate a calendar year. Resolve a yearless
+            # proposed deadline only against the admitted deadline set.
+            due_tokens = calendar_tokens(summary.get("due_date", ""))
+            if len(due_tokens) == 1 and not due_tokens[0].has_year:
+                matches = [date for date in deadline_dates if date[5:] == due_tokens[0].monthday]
+                if len(matches) == 1:
+                    summary["due_date"] = matches[0]
             if decision == "UPDATE" and target_memory is not None:
                 summary.setdefault("title", target_memory.title)
                 summary.setdefault("tags", list(target_memory.tags))
@@ -608,7 +620,7 @@ class SinglePassMemoryPlanner(MemoryPlanner):
                 allow_no_change=False,
                 allow_update_target=target_memory is not None,
             )
-            if _summary_date_grounding_violations(
+            date_violations = _summary_date_grounding_violations(
                 parsed,
                 grounded_dates=grounded_dates,
                 source_texts=[
@@ -619,11 +631,19 @@ class SinglePassMemoryPlanner(MemoryPlanner):
                     target_memory.body,
                     target_memory.due_date,
                 ) if target_memory is not None else (),
-            ):
-                raise ModelOutputError(
+            )
+            if date_violations:
+                error = ModelOutputError(
                     "B3 memory contains a date absent from admitted evidence",
                     validation_detail="relative_time",
                 )
+                # Only literal calendar tokens and program-defined field names
+                # enter diagnostics; never the rejected sentence or body.
+                fields = [field for field in ("title", "body")
+                          if any((token.canonical or token.raw) in date_violations
+                                 for token in calendar_tokens(parsed.get(field, "")))]
+                error.date_diagnostics = {"date_fields": fields, "dates": list(date_violations)}
+                raise error
             validated_candidates[candidate_id] = candidate
             return parsed
 
@@ -765,6 +785,9 @@ class SinglePassMemoryPlanner(MemoryPlanner):
                 "scope_source": target_memory.scope_source if target_memory is not None else fallback_scope_source,
                 "evidence_unit_ids": unit_ids,
             }
+            diagnostics = result.get("_defer_diagnostics", {}).get(candidate_id)
+            if isinstance(diagnostics, Mapping):
+                candidate["validation_diagnostics"] = dict(diagnostics)
             if decision == "NO_CHANGE":
                 self.audit._record_disposition(
                     turn_ref,