memleaf 0.2.37__tar.gz → 0.2.38__tar.gz

{memleaf-0.2.37 → memleaf-0.2.38}/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.38 — 2026-09-09
+
+- Unify automatic project-Scope grounding: registered and newly named model-selected projects now use the same exact candidate-bound source check. Remove the later registered-name occurrence conflict scan that could misclassify an implementation platform/product mention as ownership and reject the correct new project.
+- Strengthen final CREATE/UPDATE semantic review so a `project:<name>` Scope with `scope_source=model` is itself treated as an affiliation claim; product/platform/system/notification/implementation mentions cannot authorize project ownership, and an explicit contradictory owner defers instead of silently changing Scope.
+- Add safe per-model-call telemetry with fixed operation classes (`gate_primary`, `gate_coverage_repair`, format repair, summarize/review/coordination variants), request duration, input/output size, provider token usage, DeepSeek cache-hit/miss tokens and reasoning-token counts when supplied. Prompt/response text and credentials are never persisted.
+- Add explicit `llm.thinking` configuration for Gate/summarize/compact. The default is `low`, retaining reasoning at the lowest supported effort; users may select `disabled`, `default`, `high`, or `max` explicitly. DeepSeek OpenAI-format calls send the corresponding thinking controls.
+- Reduce Gate input cost by removing a duplicated system-policy tail and replace coverage re-checks with a narrow unresolved-evidence protocol instead of rerunning the full Gate prompt. Deterministic validation does not claim a specific real-provider latency reduction.
+
 ## 0.2.37 — 2026-09-09
 
 - Add a dedicated `memleaf-mcpw` GUI entry point for the Hermes public MCP on Windows. The GUI-subsystem launcher does not allocate a console window even when an older Hermes/MCP SDK starts it without `CREATE_NO_WINDOW`; it enters the same `memleaf.mcp_server:main` implementation and keeps the same stdio JSON-RPC protocol.

{memleaf-0.2.37/src/memleaf.egg-info → memleaf-0.2.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.37
+Version: 0.2.38
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.37。**
+> **版本：0.2.38。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.37 → memleaf-0.2.38}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.37.**
+> **Version: 0.2.38.**
 > Automatic extraction now uses only the current turn's visible user input and final assistant reply. Raw tool output, attachments, web/file/terminal payloads and legacy tool-evidence bodies are not new source evidence; existing or retrieved memory remains comparison context rather than source authority. Background processing is persisted as a local job and can be checked through the read-only `process_status` MCP tool; failed work remains retryable and fail closed. The release also tightens source/date grounding, target reconciliation, duplicate/no-op handling and semantic review before writes. 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.37 → memleaf-0.2.38}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.37。**
+> **版本：0.2.38。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.37 → memleaf-0.2.38}/pyproject.toml

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

{memleaf-0.2.37 → memleaf-0.2.38}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.37"
+__version__ = "0.2.38"
 
 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.37 → memleaf-0.2.38}/src/memleaf/config.py

@@ -19,6 +19,9 @@ MAX_REQUEST_TIMEOUT = 240
 DEFAULT_MODEL_CONCURRENCY = 3
 MIN_MODEL_CONCURRENCY = 1
 MAX_MODEL_CONCURRENCY = 8
+THINKING_PURPOSES = ("gate", "summarize", "compact")
+THINKING_MODES = frozenset({"default", "disabled", "low", "high", "max"})
+DEFAULT_THINKING = {purpose: "low" for purpose in THINKING_PURPOSES}
 
 
 def _normalize_request_timeout(value: Any) -> int | float:
@@ -41,6 +44,21 @@ def _normalize_model_concurrency(value: Any) -> int:
     return value
 
 
+def _normalize_thinking_settings(value: Any) -> dict[str, str]:
+    if value is None:
+        value = {}
+    if not isinstance(value, Mapping):
+        raise ValueError("invalid memleaf llm.thinking settings")
+    if set(value) - set(THINKING_PURPOSES):
+        raise ValueError("invalid memleaf llm.thinking settings")
+    result = dict(DEFAULT_THINKING)
+    for purpose, mode in value.items():
+        if not isinstance(mode, str) or mode not in THINKING_MODES:
+            raise ValueError("invalid memleaf llm.thinking settings")
+        result[purpose] = mode
+    return result
+
+
 DEFAULT_CONFIG: dict[str, Any] = {
     "vault": "~/.memleaf",
     "agents": {"codex": True, "hermes": True, "antigravity": False},
@@ -75,6 +93,7 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "context_window": 200000,
         "request_timeout": DEFAULT_REQUEST_TIMEOUT,
         "diagnostic_logging": False,
+        "thinking": dict(DEFAULT_THINKING),
     },
 }
 
@@ -188,6 +207,7 @@ def load_config(path: Path | str, *, vault: Path | str | None = None) -> dict[st
         raise ValueError("invalid memleaf llm settings")
     llm = dict(llm)
     llm["request_timeout"] = _normalize_request_timeout(llm.get("request_timeout", DEFAULT_REQUEST_TIMEOUT))
+    llm["thinking"] = _normalize_thinking_settings(llm.get("thinking"))
     if type(llm.get("diagnostic_logging", False)) is not bool:
         raise ValueError("invalid memleaf llm.diagnostic_logging")
     merged["llm"] = llm
@@ -231,6 +251,7 @@ def save_config(path: Path | str, config: Mapping[str, Any]) -> None:
     normalized_llm["request_timeout"] = _normalize_request_timeout(
         normalized_llm.get("request_timeout", DEFAULT_REQUEST_TIMEOUT)
     )
+    normalized_llm["thinking"] = _normalize_thinking_settings(normalized_llm.get("thinking"))
     diagnostic_logging = normalized_llm.get("diagnostic_logging", False)
     if type(diagnostic_logging) is not bool:
         raise ValueError("invalid memleaf llm.diagnostic_logging")

{memleaf-0.2.37 → memleaf-0.2.38}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.37 → memleaf-0.2.38}/src/memleaf/llm/base.py

@@ -6,6 +6,7 @@ import json
 import inspect
 import math
 import socket
+import threading
 import urllib.error
 import urllib.request
 from typing import Any, Callable, Mapping, Optional, Protocol
@@ -246,10 +247,19 @@ class HTTPModelBackend:
         self.model = model
         self.timeout = normalize_request_timeout(timeout)
         self._opener = opener or urllib.request.urlopen
+        self._call_metrics_local = threading.local()
         # The built-in stateless urllib transport can be used concurrently.
         # An injected opener is caller-owned and therefore defaults to serial.
         self.parallel_safe = opener is None
 
+    def _set_call_metrics(self, value: Mapping[str, Any] | None) -> None:
+        self._call_metrics_local.value = dict(value) if isinstance(value, Mapping) else {}
+
+    def consume_call_metrics(self) -> dict[str, Any]:
+        value = getattr(self._call_metrics_local, "value", {})
+        self._call_metrics_local.value = {}
+        return dict(value) if isinstance(value, Mapping) else {}
+
     @staticmethod
     def _is_timeout_reason(value: Any) -> bool:
         if isinstance(value, (TimeoutError, socket.timeout)):

{memleaf-0.2.37 → memleaf-0.2.38}/src/memleaf/llm/openai_compatible.py

@@ -20,10 +20,12 @@ class OpenAICompatibleBackend(HTTPModelBackend):
         opener: Optional[Callable[..., Any]] = None,
         json_mode: bool = False,
         provider_name: str = "openai",
+        thinking: Mapping[str, Any] | None = None,
     ):
         super().__init__(base_url=base_url, api_key=api_key, model=model, timeout=timeout, opener=opener)
         self.json_mode = bool(json_mode)
         self.provider_name = provider_name.casefold() if isinstance(provider_name, str) else "openai"
+        self.thinking = dict(thinking) if isinstance(thinking, Mapping) else {}
 
     @staticmethod
     def _response_text_chars(value: Any) -> int:
@@ -83,7 +85,33 @@ class OpenAICompatibleBackend(HTTPModelBackend):
             "reasoning_chars": reasoning_chars,
         }
 
+    def _thinking_mode(self, purpose: str) -> str:
+        if purpose not in {"gate", "summarize", "compact"}:
+            return "default"
+        value = self.thinking.get(purpose, "low")
+        return value if value in {"default", "disabled", "low", "high", "max"} else "low"
+
+    @staticmethod
+    def _usage_metrics(value: Mapping[str, Any], *, thinking_mode: str) -> dict[str, Any]:
+        usage = value.get("usage")
+        result: dict[str, Any] = {"thinking_mode": thinking_mode}
+        if not isinstance(usage, Mapping):
+            return result
+        for key in (
+            "prompt_tokens", "completion_tokens", "total_tokens",
+            "prompt_cache_hit_tokens", "prompt_cache_miss_tokens",
+        ):
+            item = usage.get(key)
+            if isinstance(item, int) and not isinstance(item, bool) and 0 <= item <= 10_000_000:
+                result[key] = item
+        details = usage.get("completion_tokens_details")
+        reasoning = details.get("reasoning_tokens") if isinstance(details, Mapping) else None
+        if isinstance(reasoning, int) and not isinstance(reasoning, bool) and 0 <= reasoning <= 10_000_000:
+            result["reasoning_tokens"] = reasoning
+        return result
+
     def complete(self, prompt: str, *, system: str = "", purpose: str = "", temperature: float = 0.0) -> str:
+        self._set_call_metrics({})
         messages = []
         if system:
             messages.append({"role": "system", "content": system})
@@ -93,6 +121,13 @@ class OpenAICompatibleBackend(HTTPModelBackend):
             "messages": messages,
             "temperature": temperature,
         }
+        thinking_mode = self._thinking_mode(purpose)
+        if self.provider_name == "deepseek" and thinking_mode != "default":
+            if thinking_mode == "disabled":
+                payload["thinking"] = {"type": "disabled"}
+            else:
+                payload["thinking"] = {"type": "enabled"}
+                payload["reasoning_effort"] = thinking_mode
         if self.json_mode and purpose in {"gate", "summarize", "compact"}:
             payload["response_format"] = {"type": "json_object"}
         value = self._post_json(
@@ -117,6 +152,7 @@ class OpenAICompatibleBackend(HTTPModelBackend):
                 stage=purpose,
                 validation_reason="response_shape",
             )
+        self._set_call_metrics(self._usage_metrics(value, thinking_mode=thinking_mode))
         try:
             return self._text(message.get("content"), stage=purpose)
         except ModelError as error:

{memleaf-0.2.37 → memleaf-0.2.38}/src/memleaf/llm/router.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 import os
+import threading
 from typing import Any, Callable, Mapping, Optional
 
 from .base import (
@@ -44,6 +45,7 @@ class ModelRouter:
         self.host = self._coerce_host(host)
         self.api = self._coerce_api(api) if api is not None else self._build_api()
         self.diagnostics: list[dict[str, str]] = []
+        self._call_metrics_local = threading.local()
 
     @classmethod
     def from_config(cls, config: Mapping[str, Any], **kwargs: Any) -> "ModelRouter":
@@ -122,6 +124,7 @@ class ModelRouter:
                     **kwargs,
                     json_mode=provider in _JSON_MODE_PROVIDERS,
                     provider_name=provider or "openai",
+                    thinking=config.get("thinking") if isinstance(config.get("thinking"), Mapping) else None,
                 )
         except (ModelError, ValueError, TypeError):
             return None
@@ -142,6 +145,7 @@ class ModelRouter:
         return str(getattr(backend, "provider", "unknown")), str(getattr(backend, "model", "unknown"))
 
     def _call(self, backend: ModelBackend, prompt: str, *, system: str, purpose: str, temperature: float) -> str:
+        self._call_metrics_local.value = {}
         try:
             value = backend.complete(prompt, system=system, purpose=purpose, temperature=temperature)
         except ModelError as error:
@@ -149,10 +153,23 @@ class ModelRouter:
             raise
         except Exception as error:
             raise ModelError("model backend failed", stage=purpose) from error
+        finally:
+            consume = getattr(backend, "consume_call_metrics", None)
+            if callable(consume):
+                try:
+                    metrics = consume()
+                except Exception:
+                    metrics = {}
+                self._call_metrics_local.value = dict(metrics) if isinstance(metrics, Mapping) else {}
         if not isinstance(value, str):
             raise ModelError("model backend returned non-text output", code="model_invalid_response", stage=purpose)
         return value
 
+    def consume_call_metrics(self) -> dict[str, Any]:
+        value = getattr(self._call_metrics_local, "value", {})
+        self._call_metrics_local.value = {}
+        return dict(value) if isinstance(value, Mapping) else {}
+
     def complete(self, prompt: str, *, system: str = "", purpose: str = "", temperature: float = 0.0) -> str:
         if not isinstance(prompt, str):
             raise TypeError("model prompt must be text")

{memleaf-0.2.37 → memleaf-0.2.38}/src/memleaf/memory_planner.py

@@ -15,7 +15,7 @@ from .update_coordinator import UpdateCoordinator
 from .target_reconciliation import reconcile_candidate_target
 from .evidence_policy import retain_tool_evidence
 from .parallel_model import run_ordered_keyed_jobs
-from .prompts import COVERAGE_ALREADY_COMPLETED_CORRECTION, COVERAGE_CORRECTION, GATE_SYSTEM, SUMMARIZE_SYSTEM, gate_prompt, summarize_prompt
+from .prompts import COVERAGE_ALREADY_COMPLETED_CORRECTION, COVERAGE_CORRECTION, GATE_COVERAGE_SYSTEM, GATE_SYSTEM, SUMMARIZE_SYSTEM, coverage_repair_prompt, gate_prompt, summarize_prompt
 from .retrieval import normalize_term
 from .scope_state import ScopeError, normalize_scopes
 from .validation import ModelOutputError, NO_CHANGE_DECISION, _model_scope_grounding_evidence, parse_gate_output, parse_strict_json, parse_summarize_output
@@ -37,48 +37,6 @@ def _explicit_project_scope_authorizations(scope: Any) -> tuple[str, ...]:
     )
 
 
-def _unregistered_model_project_scopes(
-    candidate: Mapping[str, Any],
-    scope_registry: Mapping[str, Any] | None,
-    authorized_scopes: Iterable[str] = (),
-) -> tuple[str, ...]:
-    """Return model-selected project scopes absent from the local registry.
-
-    The existing Gate validator deliberately accepts a new project scope when
-    the candidate memory names it.  This second check needs to distinguish
-    that case from a registered canonical name or alias, whose behavior is
-    already covered by the normal scope rules.
-    """
-
-    if candidate.get("scope_source") != "model" or not candidate.get("worth"):
-        return ()
-    scopes = tuple(
-        scope
-        for scope in candidate.get("scopes", ())
-        if isinstance(scope, str) and scope.partition(":")[0] == "project"
-    )
-    if not scopes:
-        return ()
-    selected_owners, _ = _model_scope_grounding_evidence(
-        "", scopes, scope_registry
-    )
-    registered = {
-        key.casefold()
-        for key in (scope_registry or {})
-        if isinstance(key, str) and key.partition(":")[0] == "project"
-    }
-    authorized = {
-        value.casefold()
-        for value in authorized_scopes
-        if isinstance(value, str) and value.partition(":")[0] == "project"
-    }
-    return tuple(
-        scope
-        for scope in scopes
-        if selected_owners.get(scope.casefold(), scope.casefold()) not in registered
-        and scope.casefold() not in authorized
-    )
-
 
 def _candidate_bound_source_text(
     candidate: Mapping[str, Any],
@@ -127,25 +85,37 @@ def _model_project_scope_is_source_grounded(
     scope_registry: Mapping[str, Any] | None,
     authorized_scopes: Iterable[str] = (),
 ) -> bool:
-    """Require each new model project scope to occur in its bound source.
-
-    Matching is delegated to the same registry-aware helper used by Gate
-    validation.  The input is restricted to immutable original ``EvidenceUnit``
-    text from this candidate's current batch, so candidate prose, other units,
-    related memories, domain-to-project expansion, and semantic inference
-    cannot lend a project name to this candidate.  A literal project name that
-    appears in the original source remains matchable.
+    """Validate every model-selected project Scope against exact bound source.
+
+    Registered and newly named projects intentionally use the same rule. Core
+    verifies that the selected project's canonical name or configured alias is
+    present in this candidate's immutable bound source, unless the caller
+    explicitly authorized that project Scope. Core does not infer whether some
+    other mentioned name is an owner, implementation platform, product,
+    notification source, or comparison context; semantic review owns that
+    relationship judgment.
     """
 
-    new_scopes = _unregistered_model_project_scopes(
-        candidate, scope_registry, authorized_scopes
+    if candidate.get("scope_source") != "model" or not candidate.get("worth"):
+        return True
+    scopes = tuple(
+        scope
+        for scope in candidate.get("scopes", ())
+        if isinstance(scope, str) and scope.partition(":")[0] == "project"
     )
-    if not new_scopes:
+    if not scopes:
         return True
+    authorized = {
+        value.casefold()
+        for value in authorized_scopes
+        if isinstance(value, str) and value.partition(":")[0] == "project"
+    }
     source_text = _candidate_bound_source_text(candidate, batch_units)
-    if not source_text:
-        return False
-    for scope in new_scopes:
+    for scope in scopes:
+        if scope.casefold() in authorized:
+            continue
+        if not source_text:
+            return False
         owners, matches = _model_scope_grounding_evidence(
             source_text, (scope,), scope_registry
         )
@@ -747,8 +717,9 @@ class MemoryPlanner:
             prepared_candidates: list[dict[str, Any]] = []
             for candidate in parsed["candidates"]:
                 item = dict(candidate)
-                if self.inputs._scope_evidence_conflict(item, turn, validation_scope_registry):
-                    item["_defer_reason"] = "scope_conflict"
+                # Exact candidate-bound grounding was already validated above.
+                # Do not reinterpret a second mentioned project/product/platform name
+                # as contradictory ownership with a registry-only name scan.
                 plan = self.inputs._scope_correction_plan(item, turn, validation_scope_registry)
                 if plan is not None:
                     item.pop("duplicate_memory_id", None)
@@ -937,20 +908,27 @@ class MemoryPlanner:
                     "target_relations", "unknown_target_ids", "candidate_level_target_ids",
                     "scope_correction_plans")]
                 try:
-                    correction_raw = self.model._complete(backend,
-                        "Coverage correction: classify ONLY the supplied unresolved evidence units. "
-                        "Do not re-emit already handled items. Return the same Gate JSON contract.\n"
-                        + gate_prompt([], related_memories=gate_related, scope_background=scope_background,
-                                      scope_registry=scope_registry)
-                        + evidence_prompt(missing, batch_index=batch_index, batch_count=batch_count,
-                                          todo_witnesses=todo_witnesses)
-                        + "\n"
-                        + COVERAGE_CORRECTION
-                        + "\n"
-                        + COVERAGE_ALREADY_COMPLETED_CORRECTION
-                        + "\nAlready handled candidate IDs: "
-                        + json.dumps([item["candidate_id"] for item in batch_gate["candidates"]]),
-                        system=GATE_SYSTEM, purpose="gate")
+                    correction_raw = self.model._complete(
+                        backend,
+                        coverage_repair_prompt(
+                            evidence_prompt(
+                                missing,
+                                batch_index=batch_index,
+                                batch_count=batch_count,
+                                todo_witnesses=todo_witnesses,
+                            ),
+                            related_memories=gate_related,
+                            scope_background=scope_background,
+                            scope_registry=scope_registry,
+                            already_handled_candidate_ids=[
+                                item["candidate_id"] for item in batch_gate["candidates"]
+                            ],
+                        ),
+                        system=GATE_COVERAGE_SYSTEM,
+                        purpose="gate",
+                        metric_stage="gate",
+                        metric_operation="gate_coverage_repair",
+                    )
                     correction_raw, correction_bindings = split_semantic_envelope(correction_raw)
                     correction_raw, correction_coverage = split_gate_envelope(correction_raw)
                     correction_gate = parse_gate_output(correction_raw,
@@ -1058,10 +1036,10 @@ class MemoryPlanner:
                 self.audit._record_disposition(turn_ref, candidate, "NO_CHANGE", reason="same_turn_duplicate")
                 continue
             seen_candidates.add(fingerprint)
-            # All model candidates pass the same evidence and Scope boundary.
-            if self.inputs._scope_evidence_conflict(candidate, turn, validation_scope_registry):
-                self.audit._defer_candidate(turn_ref, candidate, "scope_conflict", scopes=candidate.get("scopes", []))
-                continue
+            # Exact candidate-bound model project grounding was already
+            # validated by parse_gate. Do not run a registry-name conflict scan
+            # again here; semantic ownership/implementation roles were reviewed
+            # by the model boundary above.
             candidate_id_key = str(candidate.get("candidate_id", "")).casefold()
             correction_plan = scope_correction_plans.get(candidate_id_key)
             defer_reason = candidate.get("_defer_reason")