memleaf 0.2.11__tar.gz → 0.2.12__tar.gz

{memleaf-0.2.11 → memleaf-0.2.12}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.12 — 2026-09-02
+
+- Remove empty ASCII or Chinese parentheses left after an absolute date is
+  normalized, so permanent memory never stores values such as
+  `2026-09-03（）`.
+- Reconcile a same-scoped implementation-plan candidate with its unique active
+  project-plan memory even when the model labels the candidate as a fact or
+  omits `update_memory_id`; preserve the target's immutable type and history.
+- Exclude sent-mail, attachment, archive, and meeting records from automatic
+  plan-target inference, and defer instead of guessing when multiple project
+  plan targets remain.
+- Reject combined mailbox or daily-report count/status digests as permanent
+  memory while keeping separately emitted atomic actions eligible.
+
 ## 0.2.11 — 2026-09-02
 
 - Document one complete macOS/Linux upgrade command that upgrades the core

{memleaf-0.2.11/src/memleaf.egg-info → memleaf-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.11
+Version: 0.2.12
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,8 +23,8 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.11。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.11 通过 PyPI 分发。
+> **当前版本：0.2.12。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.12 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.11 → memleaf-0.2.12}/README.en.md

@@ -4,8 +4,8 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.11.**
-> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.11 is distributed through PyPI.
+> **Version: 0.2.12.**
+> The core library, Vault, stdio MCP server, initialization CLI, model routing, memory extraction, controlled retrieval protocol, and host adapters are implemented. memleaf 0.2.12 is distributed through PyPI.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 
 ## Project scope

{memleaf-0.2.11 → memleaf-0.2.12}/README.md

@@ -4,8 +4,8 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.11。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.11 通过 PyPI 分发。
+> **当前版本：0.2.12。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.12 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.11 → memleaf-0.2.12}/pyproject.toml

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

{memleaf-0.2.11 → memleaf-0.2.12}/src/memleaf/__init__.py

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

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

{memleaf-0.2.11 → memleaf-0.2.12}/src/memleaf/processing.py

@@ -64,6 +64,7 @@ from .validation import (
     parse_strict_json,
     parse_summarize_output,
     normalize_relative_calendar_text,
+    is_aggregate_operational_text,
 )
 from .vault import safe_component
 
@@ -1682,6 +1683,114 @@ class Processor:
         # parser has already limited the target to an active related memory.
         return candidate_scope_source in {"user", "session_context"}
 
+    @staticmethod
+    def _project_scope_keys(scopes: Any) -> set[str]:
+        if not isinstance(scopes, list):
+            return set()
+        return {
+            scope.casefold()
+            for scope in scopes
+            if isinstance(scope, str) and scope.startswith("project:")
+        }
+
+    @staticmethod
+    def _is_project_plan_title(value: Any) -> bool:
+        text = normalize_term(value) if isinstance(value, str) else ""
+        return any(
+            marker in text
+            for marker in ("实施计划", "项目计划", "implementation plan", "project plan")
+        )
+
+    @staticmethod
+    def _is_adjacent_plan_record(value: Any) -> bool:
+        text = normalize_term(value) if isinstance(value, str) else ""
+        return any(
+            marker in text
+            for marker in (
+                "已发送", "发送", "邮件", "附件", "存档", "会议", "启动会", "纪要",
+                "sent", "email", "mail", "attachment", "archive", "meeting", "minutes",
+            )
+        )
+
+    def _infer_update_target(
+        self,
+        candidate: Mapping[str, Any],
+        related: Iterable[Mapping[str, Any]],
+    ) -> dict[str, Any]:
+        """Reuse one unambiguously matching project plan/constraint memory.
+
+        The gate remains authoritative when it names a target.  This narrow
+        fallback handles a common model omission: a project-plan candidate is
+        emitted as a new ``fact`` without ``update_memory_id`` even though the
+        same scoped plan is already active.  The active target's type is the
+        canonical type; it is copied before summary validation so the target
+        type invariant remains enforced.
+        """
+
+        result = dict(candidate)
+        if (
+            not result.get("worth")
+            or result.get("duplicate")
+            or any(result.get(field) for field in ("duplicate_memory_id", "update_memory_id"))
+            or not isinstance(result.get("memory"), str)
+        ):
+            return result
+        if result.get("type") not in {"fact", "project"}:
+            return result
+        if not self._is_project_plan_title(result["memory"]):
+            return result
+        project_keys = self._project_scope_keys(result.get("scopes"))
+        if len(project_keys) != 1:
+            return result
+
+        project_matches: list[Memory] = []
+        fact_matches: list[Memory] = []
+        seen: set[str] = set()
+        for item in related:
+            if not isinstance(item, Mapping) or item.get("native") is True:
+                continue
+            memory_id = item.get("memory_id")
+            item_type = item.get("type")
+            item_scopes = item.get("scopes")
+            if (
+                not isinstance(memory_id, str)
+                or not isinstance(item_type, str)
+                or item_type not in {"fact", "project"}
+                or self._project_scope_keys(item_scopes) != project_keys
+                or memory_id.casefold() in seen
+                or not self._is_project_plan_title(item.get("title"))
+                or self._is_adjacent_plan_record(item.get("title"))
+            ):
+                continue
+            try:
+                target = Memory.from_mapping(item)
+            except (TypeError, ValueError):
+                continue
+            seen.add(memory_id.casefold())
+            if target.type == "project":
+                project_matches.append(target)
+            else:
+                fact_matches.append(target)
+
+        # Prefer a project target over a same-topic fact.  If there are
+        # multiple project targets, defer rather than creating a sibling by
+        # guessing; the same conservative rule applies when only multiple
+        # durable fact targets remain.
+        if len(project_matches) > 1 or (not project_matches and len(fact_matches) > 1):
+            result["_defer_reason"] = "ambiguous_update_target"
+            return result
+        if project_matches:
+            target = project_matches[0]
+        elif len(fact_matches) == 1:
+            target = fact_matches[0]
+        else:
+            return result
+        result["update_memory_id"] = target.memory_id
+        # The update target's type is immutable.  Correct a model's fact-vs-
+        # project label only after the same-use target was identified.
+        result["type"] = target.type
+        return result
+
     def _defer_candidate(
         self,
         turn_ref: tuple[str, str, str],
@@ -2026,6 +2135,11 @@ class Processor:
         requests: list[dict[str, Any]] = []
         observed_scopes: list[str] = []
         for candidate in gate["candidates"]:
+            # A combined mailbox/daily digest is not an atomic memory.  If a
+            # concrete action was worth retaining, the gate must emit it as
+            # its own candidate; the aggregate shell itself is NO_CHANGE.
+            if candidate.get("worth") and is_aggregate_operational_text(candidate.get("memory")):
+                continue
             candidate_scopes = list(candidate["scopes"])
             # An automatic candidate with no reliable project attribution is
             # retained as a retryable inbox turn, never silently promoted to
@@ -2075,6 +2189,11 @@ class Processor:
                 priority_only=scope_directory is not None,
                 scope_records=scoped_records if scope_directory is not None else None,
             )
+            candidate = self._infer_update_target(candidate, candidate_related)
+            defer_reason = candidate.pop("_defer_reason", None)
+            if defer_reason:
+                self._defer_candidate(turn_ref, candidate, defer_reason)
+                continue
             candidate_native_ids = [item["native_id"] for item in candidate_native_refs]
             candidate_memory_ids = [
                 item["memory_id"]

{memleaf-0.2.11 → memleaf-0.2.12}/src/memleaf/prompts.py

@@ -141,6 +141,16 @@ the current turn adds no confirmed change, use worth=false and do not create a
 sibling. If a customer or user proposes a new change without confirmation of
 implementation, preserve it as requested/proposed/pending and never state that
 it is already implemented.
+When a candidate names a project plan or project constraint already represented
+by one same-scoped active memory, prefer that exact active memory as
+update_memory_id, even when the candidate's initial type label is fact; the
+active target type is immutable and must be copied. Never create a sibling for
+the same future question/action. Prefer the durable project-plan target over
+same-topic sent-mail, attachment/archive, or meeting records; if multiple
+same-use project targets remain, do not guess an update target. A candidate
+that still combines a mailbox or daily digest shell with counts/statuses is not
+atomic: set worth=false for the aggregate, and emit any independent concrete
+action as a separate candidate.
 Return no prose, markdown fences, comments, or trailing text."""
 
 
@@ -243,6 +253,13 @@ surrounding diagnosis into a memory. If a user-confirmed future-use
 preference, identity, constraint, project risk, or durable lesson appears in
 the same evidence, summarize only that future-use topic. In explicit remember mode,
 summarize only the requested object and do not append tool/test diagnostics.
+If the gate candidate points to a same-scoped existing plan or constraint,
+update that exact target and retain its still-valid content; do not create a
+new sibling merely because the gate called it a fact. Prefer a durable project
+plan target over same-topic sent-mail, attachment/archive, or meeting records;
+the target type remains immutable. Never summarize a combined mailbox/daily
+digest shell with counts or statuses; return NO_CHANGE for that aggregate,
+while a separate atomic future-use action may still be summarized.
 Return no prose, markdown fences, comments, or trailing text."""
 
 

{memleaf-0.2.11 → memleaf-0.2.12}/src/memleaf/validation.py

@@ -104,6 +104,10 @@ _ISO_CALENDAR_DATE = re.compile(
     r"(?<![A-Za-z\d./-])\d{4}-(?:0?[1-9]|1[0-2])-(?:0?[1-9]|[12]\d|3[01])"
     r"(?![A-Za-z\d./-])"
 )
+_EMPTY_ISO_DATE_PARENTHESIS = re.compile(
+    r"(?P<date>\d{4}-(?:0?[1-9]|1[0-2])-(?:0?[1-9]|[12]\d|3[01]))"
+    r"[ \t]*(?:\([ \t]*[)）]|（[ \t]*[)）])"
+)
 _DUPLICATE_ISO_DATE = re.compile(
     r"(?P<date>\d{4}-\d{2}-\d{2})"
     r"\s*[,，、:]?\s*(?:(?:就是|即|即为|即是|也就是|是|为)|[/／])\s*"
@@ -275,6 +279,14 @@ def _collapse_duplicate_calendar_dates(value: str) -> str:
     return value
 
 
+def _strip_empty_iso_date_parenthesis(value: str) -> str:
+    """Remove empty ASCII/Chinese parentheses attached to an ISO date."""
+
+    if not isinstance(value, str):
+        return value
+    return _EMPTY_ISO_DATE_PARENTHESIS.sub(r"\g<date>", value)
+
+
 def _normalize_relative_calendar_text(
     text: str,
     anchor: Any,
@@ -328,6 +340,7 @@ def _normalize_relative_calendar_text(
     normalized = _RELATIVE_CALENDAR_EXPRESSION.sub(replace_token, text)
     if relative_replaced:
         normalized = _collapse_duplicate_calendar_dates(normalized)
+    normalized = _strip_empty_iso_date_parenthesis(normalized)
     return normalized, safe
 
 
@@ -345,6 +358,43 @@ def normalize_relative_calendar_text(text: str, anchor: Any) -> str | None:
     return normalized if safe else None
 
 
+_AGGREGATE_DIGEST_MARKERS = (
+    "日报",
+    "汇总",
+    "巡检",
+    "收件箱",
+    "邮箱巡检",
+    "daily report",
+    "digest",
+    "watchlist",
+    "mailbox sweep",
+    "inbox sweep",
+)
+_AGGREGATE_COUNT = re.compile(
+    r"(?:\d+\s*(?:条|项|个|件|封|tasks?|items?)|(?:完成|待受理|派发|新增|逾期)\s*\d+)"
+    r"|(?:completed|pending|assigned|new|overdue)\s*[:：]?\s*\d+",
+    re.IGNORECASE,
+)
+
+
+def is_aggregate_operational_text(value: Any) -> bool:
+    """Recognize a combined operational digest, not one concrete work item.
+
+    This deliberately requires multiple aggregate signals.  A single overdue
+    task reported by a daily scan remains eligible for the model's normal
+    future-use decision; a multi-count sweep must be split before persistence.
+    """
+
+    if not isinstance(value, str):
+        return False
+    folded = value.casefold()
+    if not any(marker in folded for marker in _AGGREGATE_DIGEST_MARKERS):
+        return False
+    count_signals = len(_AGGREGATE_COUNT.findall(value))
+    separator_count = len(re.findall(r"[;；]|[—-].*[;；]", value))
+    return count_signals >= 2 or (count_signals >= 1 and separator_count >= 1)
+
+
 def _reject_constant(value: str) -> None:
     raise ModelOutputError("non-finite JSON number is not allowed", validation_reason="invalid_json")
 
@@ -1022,6 +1072,9 @@ def validate_summarize_output(
     }
     _require_keys(value, {"title", "body", "tags", "type", "scopes", "sources"}, allowed)
     item = dict(value)
+    for field in ("title", "body"):
+        if isinstance(item.get(field), str):
+            item[field] = _strip_empty_iso_date_parenthesis(item[field])
     _string(item["title"], "title")
     _string(item["body"], "body", multiline=True)
     _reject_relative_calendar_expression(item)
@@ -1281,6 +1334,7 @@ __all__ = [
     "parse_gate_output",
     "parse_compact_output",
     "parse_strict_json",
+    "is_aggregate_operational_text",
     "normalize_relative_calendar_text",
     "parse_summarize_output",
     "parse_summary_output",

{memleaf-0.2.11 → memleaf-0.2.12/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.11
+Version: 0.2.12
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,8 +23,8 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **当前版本：0.2.11。**
-> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.11 通过 PyPI 分发。
+> **当前版本：0.2.12。**
+> 核心库、Vault、stdio MCP Server、初始化 CLI、模型路由、提炼流程、受控检索协议和宿主适配器已经实现。memleaf 0.2.12 通过 PyPI 分发。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 
 ## 项目定位

{memleaf-0.2.11 → memleaf-0.2.12}/tests/test_admission_noise.py

@@ -305,6 +305,59 @@ class AdmissionFlowTests(unittest.TestCase):
         self.assertEqual(len(memories), 1)
         self.assertIn("交付延期风险", memories[0].memory.body)
 
+    def test_combined_orion_digest_is_dropped_but_atomic_action_is_kept(self):
+        service = self.make_service("orion-digest")
+        backend = QueueBackend()
+        user_key, _ = self.capture_turn(
+            service,
+            session="orion-digest",
+            turn="turn-1",
+            user="查看 Orion 邮件汇总并告诉我需要关注的事项。",
+            assistant="Orion汇总：子任务完成4条；现场增补待受理2条；另派发提供旧版本生产取数脚本。",
+        )
+        aggregate = candidate(
+            "orion-aggregate",
+            [user_key],
+            memory="Orion汇总（2026-09-02）：子任务完成4条；现场增补待受理2条——另派发子任务提供旧版本生产取数脚本。",
+            type="fact",
+        )
+        aggregate["scopes"] = ["project:orion"]
+        atomic = candidate(
+            "orion-script-task",
+            [user_key],
+            memory="Orion需要提供旧版本生产取数脚本。",
+            type="todo",
+        )
+        atomic["scopes"] = ["project:orion"]
+        atomic_summary = json.loads(
+            summary(
+                user_key,
+                title="Orion提供旧版本生产取数脚本",
+                body="Orion需要提供旧版本生产取数脚本。",
+                type="todo",
+            )
+        )
+        atomic_summary.update(
+            {
+                "scopes": ["project:orion"],
+                "status": "active",
+            }
+        )
+        backend.responses.extend(
+            [gate([aggregate, atomic]), json.dumps(atomic_summary, ensure_ascii=False)]
+        )
+
+        result = service.process(source="hermes", session_id="orion-digest", model=backend)
+
+        self.assertEqual(result["memories_written"], 1)
+        self.assertEqual(result["deferred_candidates"], 0)
+        memories = service._read_memories_unlocked("knowledge")
+        self.assertEqual(len(memories), 1)
+        self.assertEqual(memories[0].memory.title, "Orion提供旧版本生产取数脚本")
+        self.assertNotIn("汇总", memories[0].memory.title)
+        self.assertNotIn("完成4条", memories[0].memory.body)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "summarize"])
+
     def test_mixed_preference_is_kept_while_mcp_failure_is_not(self):
         service = self.make_service("mixed-preference")
         backend = QueueBackend()

{memleaf-0.2.11 → memleaf-0.2.12}/tests/test_hermes_provider.py

@@ -284,7 +284,7 @@ class HermesProviderTests(unittest.TestCase):
 
     def test_provider_warns_with_one_line_update_when_core_versions_differ(self) -> None:
         client = FakeClient(responses=[{"stats": True}])
-        client.server_version = "0.2.11"
+        client.server_version = "0.2.12"
         provider = provider_module.MemleafMemoryProvider()
         with patch.object(provider_module, "_resolve_command", return_value="memleaf-mcp"), \
              patch.object(provider_module, "_MCPClient", return_value=client), \
@@ -303,11 +303,11 @@ class HermesProviderTests(unittest.TestCase):
 
     def test_provider_does_not_warn_when_core_versions_match(self) -> None:
         client = FakeClient(responses=[{"stats": True}])
-        client.server_version = "0.2.11"
+        client.server_version = "0.2.12"
         provider = provider_module.MemleafMemoryProvider()
         with patch.object(provider_module, "_resolve_command", return_value="memleaf-mcp"), \
              patch.object(provider_module, "_MCPClient", return_value=client), \
-             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.11"), \
+             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.12"), \
              patch.object(provider_module.logger, "warning") as warning:
             provider.initialize(
                 "version-match-session",
@@ -324,7 +324,7 @@ class HermesProviderTests(unittest.TestCase):
         provider = provider_module.MemleafMemoryProvider()
         with patch.object(provider_module, "_resolve_command", return_value="memleaf-mcp"), \
              patch.object(provider_module, "_MCPClient", return_value=client), \
-             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.11"), \
+             patch.object(provider_module, "_provider_manifest_version", return_value="0.2.12"), \
              patch.object(provider_module.logger, "warning") as warning:
             provider.initialize(
                 "version-missing-session",

{memleaf-0.2.11 → memleaf-0.2.12}/tests/test_pypi_install.py

@@ -81,7 +81,7 @@ class PyPIInstallTests(unittest.TestCase):
 
             self.assertTrue(target.is_dir())
             self.assertFalse(target.is_symlink())
-            self.assertIn("version: 0.2.11", (target / "plugin.yaml").read_text(encoding="utf-8"))
+            self.assertIn("version: 0.2.12", (target / "plugin.yaml").read_text(encoding="utf-8"))
 
     def test_windows_hermes_paths_follow_official_native_layout(self) -> None:
         with tempfile.TemporaryDirectory(prefix="memleaf-win-paths-") as temporary:
@@ -212,16 +212,16 @@ class PyPIInstallTests(unittest.TestCase):
             "status": "configured",
             "reason": "ok",
             "vault": "/tmp/memleaf-vault",
-            "core_version": "0.2.11",
-            "provider_version": "0.2.11",
+            "core_version": "0.2.12",
+            "provider_version": "0.2.12",
             "model": {"status": "configured"},
         }
         with mock.patch("memleaf.installer.install_hermes", return_value=result), \
              mock.patch("sys.stdout") as stdout:
             self.assertEqual(cli.main(["install"]), 0)
         output = "\n".join(str(call.args[0]) for call in stdout.write.call_args_list)
-        self.assertIn("core=0.2.11", output)
-        self.assertIn("Hermes provider=0.2.11", output)
+        self.assertIn("core=0.2.12", output)
+        self.assertIn("Hermes provider=0.2.12", output)
 
     def test_readmes_document_one_line_core_and_provider_upgrade(self) -> None:
         command = "python -m pip install -U memleaf && python -m memleaf install"

{memleaf-0.2.11 → memleaf-0.2.12}/tests/test_stage_b1.py

@@ -23,7 +23,12 @@ from memleaf.prompts import (
     gate_prompt,
     summarize_prompt,
 )
-from memleaf.validation import ModelOutputError, NO_CHANGE_DECISION, normalize_relative_calendar_text
+from memleaf.validation import (
+    ModelOutputError,
+    NO_CHANGE_DECISION,
+    is_aggregate_operational_text,
+    normalize_relative_calendar_text,
+)
 from memleaf.index import event_key, turn_key
 from memleaf.llm import (
     CallableBackend,
@@ -398,6 +403,48 @@ class StageB1Test(unittest.TestCase):
         self.assertIsNone(normalize_relative_calendar_text("明天完成", None))
         self.assertIsNone(normalize_relative_calendar_text("明天完成", "invalid"))
 
+    def test_date_parentheses_are_removed_only_when_empty(self):
+        anchor = "2026-09-02T02:01:41Z"
+        self.assertEqual(
+            normalize_relative_calendar_text("2026-09-03（）", anchor),
+            "2026-09-03",
+        )
+        self.assertEqual(
+            normalize_relative_calendar_text("2026-09-03()", anchor),
+            "2026-09-03",
+        )
+        summary = {
+            "title": "反馈截止 2026-09-03（）",
+            "body": "English spelling: 2026-09-03()",
+            "tags": [],
+            "type": "todo",
+            "scopes": ["global"],
+            "sources": [{"event_key": "event-a"}],
+            "status": "active",
+        }
+        parsed = parse_summarize_output(json.dumps(summary), current_event_keys=["event-a"])
+        self.assertEqual(parsed["title"], "反馈截止 2026-09-03")
+        self.assertEqual(parsed["body"], "English spelling: 2026-09-03")
+        self.assertEqual(
+            parse_summarize_output(
+                json.dumps(dict(summary, body="2026-09-03（周四）")),
+                current_event_keys=["event-a"],
+            )["body"],
+            "2026-09-03（周四）",
+        )
+
+    def test_aggregate_operational_detector_requires_a_combined_digest(self):
+        self.assertTrue(
+            is_aggregate_operational_text(
+                "Orion汇总（2026-09-02）：子任务完成4条；现场增补待受理2条——另派发1条。"
+            )
+        )
+        self.assertFalse(
+            is_aggregate_operational_text(
+                "Orion项目巡检：浦银安盛任务提供测试数据逾期5天。"
+            )
+        )
+
     def test_process_retries_schema_violation_until_third_gate_attempt_and_commits(self):
         responses = [
             json.dumps({"candidates": "invalid"}),

{memleaf-0.2.11 → memleaf-0.2.12}/tests/test_stage_b2a.py

@@ -1255,6 +1255,193 @@ class StageB2ATest(unittest.TestCase):
         self.assertEqual(service.read(old.memory_id).body, "金元顺安实施计划新增部署要求。")
         self.assertEqual(len(service.vault.list_markdown("history")), 1)
 
+    def test_same_project_plan_fact_candidate_is_reconciled_to_immutable_project_target(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="inferred-plan-update")
+        old = service.create_memory(
+            memory_id="mem-zhongyin-plan",
+            title="中银国际员工投资行为申报系统信创改造实施计划",
+            body="中银国际实施计划当前按原始安排执行。",
+            type="project",
+            scopes=["project:中银国际"],
+        )
+        user_key, assistant_key = self.capture_turn(
+            service,
+            turn="inferred-plan-update",
+            user_event="inferred-plan-update-user",
+            assistant_event="inferred-plan-update-assistant",
+            user="中银国际客户提出实施计划调整建议。",
+            assistant="已记录中银国际实施计划调整建议，待更新计划。",
+        )
+        candidate = self.candidate(
+            "zhongyin-plan-feedback",
+            [user_key, assistant_key],
+            memory="中银国际客户提出实施计划调整建议：提前部署测试环境并重新压实计划。",
+            type="fact",
+        )
+        candidate["scopes"] = ["project:中银国际"]
+        backend.responses.extend(
+            [
+                self.gate([candidate]),
+                self.summary(
+                    user_key,
+                    title=old.title,
+                    body="中银国际实施计划当前按原始安排执行；客户提出提前部署测试环境并重新压实计划。",
+                    type="project",
+                    scopes=["project:中银国际"],
+                ),
+            ]
+        )
+
+        result = service.process(source="codex", session_id="s", model=backend)
+
+        self.assertEqual(result["memory_ids"], [old.memory_id])
+        self.assertEqual(len(self.knowledge(service)), 1)
+        self.assertEqual(service.read(old.memory_id).type, "project")
+        self.assertIn("原始安排", service.read(old.memory_id).body)
+        self.assertIn("提前部署测试环境", service.read(old.memory_id).body)
+        self.assertEqual(len(service.vault.list_markdown("history")), 1)
+        self.assertNotIn("update_target_type_mismatch", " ".join(call["prompt"] for call in backend.calls))
+
+    def test_project_plan_target_wins_over_sent_mail_for_zhongyin_and_jinyuan(self):
+        cases = (
+            (
+                "zhongyin",
+                "中银国际",
+                "中银国际员工申报系统信创改造实施计划",
+                "陈国金",
+            ),
+            (
+                "jinyuan",
+                "金元顺安",
+                "金元顺安员工投资行为申报系统信创改造实施计划",
+                "方明",
+            ),
+        )
+        for slug, project, plan_title, recipient in cases:
+            with self.subTest(project=project):
+                backend = QueueBackend()
+                service = self.service(backend, name=f"multi-target-{slug}")
+                plan = service.create_memory(
+                    memory_id=f"mem-{slug}-plan",
+                    title=plan_title,
+                    body=f"{project}实施计划当前按原始安排执行。",
+                    type="project",
+                    scopes=[f"project:{project}"],
+                )
+                adjacent = []
+                for suffix, title, body in (
+                    (
+                        "sent-mail",
+                        f"已发送{plan_title}邮件给{recipient}",
+                        f"已向{recipient}发送{project}实施计划邮件。",
+                    ),
+                    (
+                        "attachment",
+                        f"{project}实施计划附件清单",
+                        f"{project}实施计划附件已归档。",
+                    ),
+                    (
+                        "meeting",
+                        f"{project}实施计划会议纪要",
+                        f"{project}实施计划会议已完成。",
+                    ),
+                ):
+                    adjacent.append(
+                        service.create_memory(
+                            memory_id=f"mem-{slug}-{suffix}",
+                            title=title,
+                            body=body,
+                            type="fact",
+                            scopes=[f"project:{project}"],
+                        )
+                    )
+                user_key, assistant_key = self.capture_turn(
+                    service,
+                    turn=f"multi-target-{slug}",
+                    user_event=f"multi-target-{slug}-user",
+                    assistant_event=f"multi-target-{slug}-assistant",
+                    user=f"{project}客户提出实施计划调整建议。",
+                    assistant=f"已记录{project}实施计划的新约束，待更新计划。",
+                )
+                candidate = self.candidate(
+                    f"{slug}-plan-feedback",
+                    [user_key, assistant_key],
+                    memory=f"{project}客户提出实施计划调整建议：提前部署测试环境并重新压实计划。",
+                    type="fact",
+                )
+                candidate["scopes"] = [f"project:{project}"]
+                backend.responses.extend(
+                    [
+                        self.gate([candidate]),
+                        self.summary(
+                            user_key,
+                            title=plan_title,
+                            body=(
+                                f"{project}实施计划当前按原始安排执行；"
+                                "客户提出提前部署测试环境并重新压实计划。"
+                            ),
+                            type="project",
+                            scopes=[f"project:{project}"],
+                        ),
+                    ]
+                )
+
+                result = service.process(source="codex", session_id="s", model=backend)
+
+                self.assertEqual(result["memory_ids"], [plan.memory_id])
+                self.assertEqual([call["purpose"] for call in backend.calls], ["gate", "summarize"])
+                self.assertEqual(len(self.knowledge(service)), 4)
+                self.assertIn("提前部署测试环境", service.read(plan.memory_id).body)
+                for record in adjacent:
+                    self.assertEqual(service.read(record.memory_id).body, record.body)
+                self.assertEqual(len(service.vault.list_markdown("history")), 1)
+
+    def test_multiple_same_project_plan_targets_are_deferred_without_sibling(self):
+        backend = QueueBackend()
+        service = self.service(backend, name="ambiguous-project-plan-target")
+        for memory_id, title in (
+            ("mem-jinyuan-plan-test", "金元顺安实施计划：测试环境"),
+            ("mem-jinyuan-plan-release", "金元顺安实施计划：上线安排"),
+        ):
+            service.create_memory(
+                memory_id=memory_id,
+                title=title,
+                body=f"{title}按原始安排执行。",
+                type="project",
+                scopes=["project:金元顺安"],
+            )
+        user_key, assistant_key = self.capture_turn(
+            service,
+            turn="ambiguous-project-plan-target",
+            user_event="ambiguous-project-plan-target-user",
+            assistant_event="ambiguous-project-plan-target-assistant",
+            user="金元顺安客户提出实施计划调整建议。",
+            assistant="已记录金元顺安实施计划的新约束，待确认对应计划。",
+        )
+        candidate = self.candidate(
+            "ambiguous-jinyuan-plan-feedback",
+            [user_key, assistant_key],
+            memory="金元顺安实施计划",
+            type="fact",
+        )
+        candidate["scopes"] = ["project:金元顺安"]
+        backend.responses.append(self.gate([candidate]))
+
+        result = service.process(source="codex", session_id="s", model=backend)
+
+        self.assertEqual(result["memory_ids"], [])
+        self.assertEqual(result["memories_written"], 0)
+        self.assertEqual(result["deferred_candidates"], 1)
+        self.assertEqual([call["purpose"] for call in backend.calls], ["gate"])
+        self.assertEqual(
+            self.processed(service)["sessions"]["codex/s"]["processed_turns"][0]["deferred_candidates"][0]["reason"],
+            "ambiguous_update_target",
+        )
+        self.assertEqual(len(self.knowledge(service)), 2)
+        self.assertEqual(len(service.vault.list_markdown("history")), 0)
+        self.assertTrue((service.vault.inbox_path / "codex" / "s.md").is_file())
+
     def test_same_project_wrong_update_target_final_retry_becomes_create(self):
         backend = QueueBackend()
         service = self.service(backend, name="same-project-wrong-target-final-retry")

{memleaf-0.2.11 → memleaf-0.2.12}/tests/test_stage_c1_mcp.py

@@ -104,7 +104,7 @@ class StageC1MCPTest(unittest.TestCase):
         testcase.assertEqual(result["resultType"], "complete")
         testcase.assertEqual(
             result["_meta"]["io.modelcontextprotocol/serverInfo"],
-            {"name": "memleaf", "version": "0.2.11"},
+            {"name": "memleaf", "version": "0.2.12"},
         )
         return result
 

{memleaf-0.2.11 → memleaf-0.2.12}/tests/test_stage_c3_packaging.py

@@ -24,7 +24,7 @@ class StageC3PackagingTests(unittest.TestCase):
 
     def test_project_metadata_and_version_export(self) -> None:
         self.assertEqual(self.project["name"], "memleaf")
-        self.assertEqual(self.project["version"], "0.2.11")
+        self.assertEqual(self.project["version"], "0.2.12")
         self.assertEqual(self.project["requires-python"], ">=3.11")
         self.assertEqual(self.project["dependencies"], [])
         self.assertEqual(self.project["license"], "MIT")