memleaf 0.2.48__tar.gz → 0.2.50__tar.gz

{memleaf-0.2.48 → memleaf-0.2.50}/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.50 — 2026-09-13
+
+- Remove the six-item cap on the related-memory catalog. It contradicted the retrieval design outright. Retrieval injects the scope list and resolves the scope the planner selects; a Vault whose memories all carry one scope -- `global`, which is the common personal case and the only scope in an empty registry -- correctly resolves that scope to the whole library, and six rows then hid most of it. Measured on a real Vault of 18 memories, every one `global`: retrieval returned 19 rows, the cap kept 6, discarded 13, and the discarded rows marked the lookup unprovable, so every turn died with `incomplete B3 lookup cannot authorize a terminal decision`. Size, not count, is what the prompt budget is about, and the character ceiling already expresses it.
+- Derive that ceiling from the prompt budget instead of a round number, and downgrade it to a safety net. `_RELATED_MAX_CHARS` was 6000, which on the same Vault sat just below the whole library and so bound continuously; it is now 40000, chosen against `MAX_PROMPT_BYTES` (192 KiB) at the measured ~1.6 UTF-8 bytes per catalog row, which leaves well over 100 KiB for the contract, the current evidence and the native catalog and admits roughly 180 memories. It no longer expresses a working constraint, only the guarantee that the hard prompt limit cannot be reached.
+- Stop treating a trimmed body as a withheld record. A body shortened to fit the catalog budget is still projected -- its id, title, type and scopes are all present, so it can still be targeted and still rules out a duplicate CREATE -- yet it was recorded as withheld and made `lookup_complete` false. Only a record actually dropped from the projection can carry that weight now, whether by the ceiling or because it could not be projected at all. The 1600-character per-body bound is unchanged: it guards against one pathological memory consuming the whole catalog, and at the measured distribution (bodies average 146 characters, p90 194) it does not bind in normal use.
+- Defer the candidate that needs the missing proof instead of discarding the turn. Only a CREATE claims novelty, and only a complete lookup can prove it, so a CREATE under an incomplete lookup is now deferred with the protocol's own `lookup_incomplete` reason -- the vocabulary already declared it -- and recorded as `b3_candidate_deferred_count`. UPDATE and NO_CHANGE name a target that is in the supplied catalog by construction, so they remain provable and still commit. The turn-level failure that refused every terminal decision is gone.
+- Keep the extraction worker, the installer's host CLI probes and the adapter runner from opening a console window. All three ran on Windows without `CREATE_NO_WINDOW`; the worker asked for `DETACHED_PROCESS`, which does not help, because a console program still needs a console and Windows creates a visible one. Whenever the host had no console of its own -- the Hermes desktop app, for instance -- every captured turn put a stray terminal on the user's desktop. Measured on Windows 11 with Windows Terminal as the default host: `CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS` opened one new console window titled with the interpreter path, `CREATE_NO_WINDOW` opened none. The worker keeps its own process group so a Ctrl+C aimed at the parent's console does not take it down.
+
+Verification for this release used the reported production Vault. 100 tests pass with no model call, covering the item-count regression directly (an 18-memory and a 60-memory library must both stay complete), the trimmed-versus-withheld distinction, the still-fail-closed cases for a genuinely withheld local record and an unprojectable one, the incomplete-lookup deferral for CREATE, UPDATE and NO_CHANGE, the reconciler not treating a deferred member as a collision, and all three spawn sites. The real replay retried the four turns that had failed: the lookup reported `lookup_complete: true` with all 18 rows projected, two preview runs returned `execution_status: ok` with `coverage_status: complete`, the committed run processed all four previously failing turns and wrote six memories, and the Vault then reported `failed_sessions: 0`, `failed_turns: 0`, `retryable: false` with a clean audit. Compaction is still not wired to any automatic caller, so an active-memory ceiling remains absent in normal operation; that and the question of whether retrieval should select by relevance when several scopes exist are left open rather than assumed.
+
+## 0.2.49 — 2026-09-13
+
+- Restore candidate-local deferral to the B3 single-pass path. v0.2.26 established that an invalid proposal receives bounded model correction and then explicit candidate-local deferral while "valid siblings proceed", and v0.2.34 required that "candidate-local deferral and idempotent partial retries" be preserved so unresolved ownership, target, evidence or timing never fabricates a write. The B3 planner had lost that property: the first proposal Core rejected raised out of the parser and discarded every other verdict in the turn, so one model slip cost the whole turn even when six other candidates were sound. A proposal that Core can attribute to a single candidate is now deferred with a B3 defer reason and the rest of the turn still commits. Nothing is written for a deferred candidate, no extra model call is made, and the turn stays retryable with its already-settled units intact.
+- Keep the deferral boundary narrow and explicit. Only details that describe the candidate itself are converted: scope authorisation and update-target problems map to `scope_ambiguous` and `target_ambiguous`, while a malformed proposal (todo fields, ungrounded or malformed dates, type, source shape) maps to `maintenance_uncertain` and missing admitted evidence maps to `evidence_insufficient`. Every other failure — transport, truncation, envelope shape, evidence coverage, binding scope, and any detail Core does not recognise — still fails the whole turn closed, so a systemic fault cannot hide behind a deferral.
+- Make the deferral visible rather than silent. Each one is counted as `b3_candidate_deferred_count` on the turn, the cause is recorded against the candidate, and the deferred work continues to surface through `deferred_candidates`, `retryable_deferred_turns` and `coverage_status: partial` in the read-only processing status. The persisted cause is restricted to a bounded identifier so no model text can reach state files.
+- Keep the deferral from being mistaken for a collision. Same-target reconciliation groups items that reach a terminal disposition for one memory, and a deferred candidate reaches none: it writes nothing, carries no update target, and cannot conflict with an admitted update to the same memory. Only the candidates that actually reach UPDATE or NO_CHANGE are grouped now, so a turn that updates one memory and defers another does not spend its second request reconciling a candidate that was never admitted.
+
+Verification for this release repeated the same real-model replay used for 0.2.48 and added focused synthetic tests: 90 tests pass with no model call, covering the sibling-commits case, every deferrable detail and the reason it maps to, deferral being driven by an explicit allowlist, the optional argument for direct parser callers, a deferred member not being grouped as a same-target collision, and the turn-level failures that must still abort. Three further preview runs of the previously failing production session completed with `execution_status: ok` and `coverage_status: complete`. A deferral is a visible degradation rather than a success: the candidate is retried, not written, and a prompt or configuration fault that made every proposal invalid would now show up as a fully deferred turn rather than as a hard failure.
+
 ## 0.2.48 — 2026-09-13
 
 - Restore same-target reconciliation in the B3 single-pass path. A real turn was discarded with `B3 target referenced more than once` whenever the model admitted two changes for one existing memory. One memory can only receive one terminal disposition per turn, because the writer archives the previous version and overwrites the same file, so the colliding items are now reconciled with one bounded call into a single current state and an unresolvable group is deferred as `target_ambiguous` instead of guessed. This is the capability the legacy staged path already had; it is not a new retry class, and the compact contract now tells the model to merge such changes into one UPDATE in the first place. The call is charged against the same two-request turn budget as the primary extraction and its structural repair, so a collision can never lengthen a turn: when a repair has already spent the budget, the group defers and every other item still commits. The strict "a target may be used once" rejection remains in the parser for direct callers.

{memleaf-0.2.48/src/memleaf.egg-info → memleaf-0.2.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.48
+Version: 0.2.50
 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.48。**
+> **版本：0.2.50。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.48 → memleaf-0.2.50}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.48.**
+> **Version: 0.2.50.**
 > 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.48 → memleaf-0.2.50}/README.md

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

{memleaf-0.2.48 → memleaf-0.2.50}/pyproject.toml

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

{memleaf-0.2.48 → memleaf-0.2.50}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.48"
+__version__ = "0.2.50"
 
 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.48 → memleaf-0.2.50}/src/memleaf/adapters/base.py

@@ -24,6 +24,7 @@ from pathlib import Path
 from typing import Any, Callable, Mapping, Sequence
 
 from ..locking import VaultLock, atomic_write_json, read_json
+from ..subprocess_flags import hidden_popen_kwargs
 
 
 @dataclass(frozen=True)
@@ -453,6 +454,7 @@ def _subprocess_runner(
         "errors": "strict",
         "env": dict(env),
     }
+    options.update(hidden_popen_kwargs())
     if input_text is not None:
         options["input"] = input_text
     return subprocess.run(list(argv), **options)

{memleaf-0.2.48 → memleaf-0.2.50}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.48 → memleaf-0.2.50}/src/memleaf/installer.py

@@ -42,6 +42,7 @@ from .hermes_runtime import (
 )
 from .locking import atomic_write_json
 from .native_registration import ensure_hermes_native_sources
+from .subprocess_flags import hidden_popen_kwargs
 from .vault import Vault
 
 
@@ -357,6 +358,7 @@ def _run(
         "errors": "strict",
         "check": False,
     }
+    options.update(hidden_popen_kwargs())
     if timeout is not None:
         options["timeout"] = timeout
     return subprocess.run(command, **options)

{memleaf-0.2.48 → memleaf-0.2.50}/src/memleaf/planning_context.py

@@ -11,7 +11,7 @@ from .native_index import NativeIndexer
 from .retrieval import candidate_matches_query, filter_by_scope, normalize_term
 from .scope_state import project_scopes_for_domains
 from .scope_maintenance import ScopeMaintenanceError, scope_registry_projection
-from .process_common import ProcessingError, _RELATED_MAX_BODY_CHARS, _RELATED_MAX_CHARS, _RELATED_MAX_ITEMS, _SCOPE_CORRECTION_MARKER_RE, _SCOPE_DIRECTORY_MAX_CHARS, _SCOPE_DIRECTORY_MAX_ITEMS, _SCOPE_DIRECTORY_MAX_TITLE_CHARS, _TARGET_NOT_RELATED, _TARGET_SAME_USE, _TARGET_UNKNOWN, _invoke_native, _merge_related, _native_result, _safe_scope_background, _session_key
+from .process_common import ProcessingError, _RELATED_MAX_BODY_CHARS, _RELATED_MAX_CHARS, _SCOPE_CORRECTION_MARKER_RE, _SCOPE_DIRECTORY_MAX_CHARS, _SCOPE_DIRECTORY_MAX_ITEMS, _SCOPE_DIRECTORY_MAX_TITLE_CHARS, _TARGET_NOT_RELATED, _TARGET_SAME_USE, _TARGET_UNKNOWN, _invoke_native, _merge_related, _native_result, _safe_scope_background, _session_key
 
 
 class PlanningContext:
@@ -317,31 +317,35 @@ class PlanningContext:
         complete = True
 
         def _drop(item: Mapping[str, Any]) -> None:
-            """Record one related record that could not be projected verbatim.
+            """Record one related record that was withheld from the projection.
 
             ``complete`` answers one question only: can Core still prove that no
             **local** record was withheld, so that an absent UPDATE target and a
-            create-safe lookup remain provable?  Native sources are read-only
-            host files that are never an UPDATE or NO_CHANGE target and are only
-            ever referenced through ``shadow_native_ids``, so clipping one must
-            not make the whole lookup unprovable.  Treating a long host memory
-            file as a failed proof would block every automatic extraction with no
-            way for the user to recover except shrinking a file they own.
+            create-safe lookup remain provable?
+
+            Only a withheld record counts.  A body trimmed to fit is still
+            projected -- its identity, type and scopes are all present, so it can
+            still be targeted and still rules out a duplicate CREATE -- and
+            marking that as an unprovable lookup would make ordinary Vault growth
+            fail turns.
+
+            Native sources are read-only host files that are never an UPDATE or
+            NO_CHANGE target and are only ever referenced through
+            ``shadow_native_ids``, so clipping one must not make the whole lookup
+            unprovable either.  Treating a long host memory file as a failed
+            proof would block every automatic extraction with no way for the user
+            to recover except shrinking a file they own.
             """
 
             nonlocal complete
             if item.get("native") is not True:
                 complete = False
 
-        for index, value in enumerate(values):
-            if len(selected) >= _RELATED_MAX_ITEMS:
-                for item in values[index:]:
-                    _drop(item)
-                break
+        for value in values:
             body = value.get("body")
             if isinstance(body, str) and len(body) > _RELATED_MAX_BODY_CHARS:
+                # Trimmed, not withheld: the record keeps its identity.
                 value["body"] = body[: _RELATED_MAX_BODY_CHARS - 1].rstrip() + "…"
-                _drop(value)
             size = cls._related_payload_size(value)
             if size < 0:
                 _drop(value)
@@ -364,9 +368,10 @@ class PlanningContext:
                 if size < 0 or used + size + (1 if selected else 0) > _RELATED_MAX_CHARS:
                     _drop(value)
                     continue
+                # A priority target kept in reduced form is still projected, so
+                # its identity is not withheld and the proof survives.
                 value = minimal
                 additional = size + (1 if selected else 0)
-                _drop(value)
             selected.append(value)
             used += additional
         return selected, complete

{memleaf-0.2.48 → memleaf-0.2.50}/src/memleaf/process_common.py

@@ -259,15 +259,32 @@ _DIAGNOSTIC_SUMMARY_ALLOWED = frozenset(
 )
 
 
-_RELATED_MAX_ITEMS = 6
-
-
+# The comparison catalog is the only part of the B3 prompt that grows with the
+# Vault, so it needs a ceiling -- but the ceiling must be a safety net for the
+# prompt's own hard limit, never a constraint that decides whether a turn may
+# write.
+#
+# It used to be six items, which contradicted the retrieval design outright: a
+# Vault whose memories all carry one scope (``global``, the common personal
+# case, and the only scope in an empty registry) correctly resolves that scope
+# to the whole library, and six rows then hid most of it.  Withholding a local
+# record is also what marks the lookup unprovable, so a small item cap turned
+# ordinary growth into failing turns.
+#
+# The ceiling is now derived from the prompt budget instead of chosen as a round
+# number.  ``MAX_PROMPT_BYTES`` is 192 KiB; a catalog row measures about 1.6
+# UTF-8 bytes per character in practice, so 40000 characters is roughly 64 KiB,
+# leaving well over 100 KiB for the contract, the current evidence and the
+# native catalog.  That admits roughly 180 memories at the observed row size --
+# far beyond the point where compaction is meant to bring the active set down.
+_RELATED_MAX_CHARS = 40000
+
+
+# A single pathological body must not consume the whole catalog budget.  This
+# only ever fires on a memory far longer than an atomic fact.
 _RELATED_MAX_BODY_CHARS = 1600
 
 
-_RELATED_MAX_CHARS = 6000
-
-
 _SCOPE_DIRECTORY_MAX_ITEMS = 8
 
 

{memleaf-0.2.48 → memleaf-0.2.50}/src/memleaf/process_jobs.py

@@ -23,6 +23,7 @@ from typing import Any, Mapping
 from .locking import atomic_write_json, read_json
 from .extraction_budget import aggregate_extraction_metrics
 from .service import Memleaf
+from .subprocess_flags import hidden_popen_kwargs
 from .vault import Vault, safe_component
 
 
@@ -554,7 +555,10 @@ def _launch(vault: Vault, job_id: str) -> subprocess.Popen[Any]:
         "close_fds": True,
     }
     if os.name == "nt":
-        kwargs["creationflags"] = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) | getattr(subprocess, "DETACHED_PROCESS", 0)
+        # A windowless child, not a detached one: see subprocess_flags.  The
+        # detached flag a previous release used opened a stray console window
+        # on the user's desktop for every captured turn.
+        kwargs.update(hidden_popen_kwargs())
     else:
         kwargs["start_new_session"] = True
     return subprocess.Popen(command, **kwargs)

{memleaf-0.2.48 → memleaf-0.2.50}/src/memleaf/single_pass_plan.py

@@ -45,6 +45,29 @@ _DEFER_REASONS = frozenset({
     "lookup_incomplete",
     "maintenance_uncertain",
 })
+# A rejected proposal is a candidate-local problem, not a turn-local one.
+# v0.2.26 established that "invalid proposals receive bounded model correction,
+# then explicit candidate-local deferral; valid siblings proceed", and v0.2.34
+# required that candidate-local deferral and idempotent partial retries be
+# preserved.  Only details that describe the candidate itself are listed here:
+# anything unrecognised, and every transport or invariant failure, still fails
+# the whole turn closed.
+_B3_DEFERRABLE_DETAILS = {
+    "scope_not_grounded": "scope_ambiguous",
+    "scope_drift": "scope_ambiguous",
+    "invalid_scope": "scope_ambiguous",
+    "invalid_scope_source": "scope_ambiguous",
+    "invalid_update_target": "target_ambiguous",
+    "duplicate_update_target": "target_ambiguous",
+    "invalid_due_date": "maintenance_uncertain",
+    "due_date_not_grounded": "maintenance_uncertain",
+    "relative_time": "maintenance_uncertain",
+    "todo_fields": "maintenance_uncertain",
+    "invalid_type": "maintenance_uncertain",
+    "source_shape": "maintenance_uncertain",
+    "invalid_evidence": "evidence_insufficient",
+}
+_DETAIL_TEXT_RE = re.compile(r"^[a-z_]{1,48}$")
 _MEMORY_FIELDS = frozenset({
     "title", "body", "tags", "aliases", "keywords", "status", "completed_at", "due_date",
     "shadow_native_ids",
@@ -409,6 +432,7 @@ def parse_single_pass_output(
     validate_memory: MemoryValidator,
     target_rows: list[dict[str, Any]] | None = None,
     normalizations: list[str] | None = None,
+    deferrals: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     if not callable(validate_memory):
         raise TypeError("validate_memory must be callable")
@@ -466,6 +490,7 @@ def parse_single_pass_output(
     used_targets: set[str] = set()
     binding_rows: list[dict[str, Any]] = []
     prepared: list[tuple[dict[str, Any], Mapping[str, Any] | None]] = []
+    forced_defer: dict[str, str] = {}
 
     for item_index, raw_item in enumerate(items):
         item_path = f"items[{item_index}]"
@@ -525,11 +550,14 @@ def parse_single_pass_output(
                 path=item_path, rule="relationship", actual=raw_item,
                 expected_type="object", missing_fields=("scopes",),
             )
-        if decision in {"CREATE", "UPDATE", "NO_CHANGE"} and not lookup_complete:
-            raise ModelOutputError(
-                "incomplete B3 lookup cannot authorize a terminal decision",
-                validation_detail="other_schema_violation",
-            )
+        if decision == "CREATE" and not lookup_complete:
+            # Only a CREATE claims novelty, and only a complete lookup can prove
+            # it.  The candidate cannot be written, but nothing else in the turn
+            # depends on this proof, so it is deferred with the protocol's own
+            # reason instead of discarding every other verdict.  UPDATE and
+            # NO_CHANGE name a target that is in the supplied catalog by
+            # construction, so they stay provable without it.
+            forced_defer[candidate_key] = "lookup_incomplete"
         candidate_ids.add(candidate_key)
         claims = raw_item.get("evidence")
         if isinstance(claims, Mapping):
@@ -717,30 +745,69 @@ def parse_single_pass_output(
     for item, target_record in prepared:
         candidate_id = item["candidate_id"]
         decision = item["decision"]
+        evidence = [dict(claim) for claim in bindings[candidate_id]]
+        forced = forced_defer.get(candidate_id.casefold())
+        if forced is not None:
+            normalized_items.append({
+                "candidate_id": candidate_id,
+                "decision": "DEFERRED",
+                "reason": forced,
+                "evidence": evidence,
+            })
+            if deferrals is not None:
+                deferrals.append({
+                    "candidate_id": candidate_id,
+                    "reason": forced,
+                    "detail": forced,
+                })
+            continue
         normalized: dict[str, Any] = {
             "candidate_id": candidate_id,
             "decision": decision,
-            "evidence": [dict(claim) for claim in bindings[candidate_id]],
+            "evidence": evidence,
         }
-        if decision == "CREATE":
-            validated = validate_memory(
-                candidate_id, decision, None, None, item["memory"], normalized["evidence"], item,
-            )
-            normalized.update({
-                "type": item["type"], "scopes": list(item["scopes"]), "memory": dict(validated),
-            })
-        elif decision == "UPDATE":
-            target_id = item["target_memory_id"]
-            validated = validate_memory(
-                candidate_id, decision, target_id, target_record,
-                item["memory"], normalized["evidence"], item,
-            )
-            normalized["target_memory_id"] = target_id
-            normalized["memory"] = dict(validated)
-        elif decision == "NO_CHANGE":
-            normalized["target_memory_id"] = item["target_memory_id"]
-        else:
-            normalized["reason"] = item["reason"]
+        try:
+            if decision == "CREATE":
+                validated = validate_memory(
+                    candidate_id, decision, None, None, item["memory"], evidence, item,
+                )
+                normalized.update({
+                    "type": item["type"], "scopes": list(item["scopes"]), "memory": dict(validated),
+                })
+            elif decision == "UPDATE":
+                target_id = item["target_memory_id"]
+                validated = validate_memory(
+                    candidate_id, decision, target_id, target_record,
+                    item["memory"], evidence, item,
+                )
+                normalized["target_memory_id"] = target_id
+                normalized["memory"] = dict(validated)
+            elif decision == "NO_CHANGE":
+                normalized["target_memory_id"] = item["target_memory_id"]
+            else:
+                normalized["reason"] = item["reason"]
+        except ModelOutputError as error:
+            detail = getattr(error, "validation_detail", None)
+            reason = _B3_DEFERRABLE_DETAILS.get(detail) if isinstance(detail, str) else None
+            if reason is None:
+                raise
+            # The proposal is unsafe to write, but its siblings are unaffected.
+            # Defer this one candidate so the turn keeps every verdict it can
+            # justify, and record the cause instead of failing silently.
+            normalized = {
+                "candidate_id": candidate_id,
+                "decision": "DEFERRED",
+                "reason": reason,
+                "evidence": evidence,
+            }
+            if deferrals is not None:
+                deferrals.append({
+                    "candidate_id": candidate_id,
+                    "reason": reason,
+                    "detail": (
+                        detail if _DETAIL_TEXT_RE.fullmatch(detail) else "unrecognised_detail"
+                    ),
+                })
         normalized_items.append(normalized)
     return {"protocol_version": PROTOCOL_VERSION, "items": normalized_items, "no_memory": normalized_no_memory}
 
@@ -1060,10 +1127,12 @@ def run_single_pass_stage(
     primary_system = "" if inline_system else SINGLE_PASS_SYSTEM
     target_rows: list[dict[str, Any]] = []
     normalizations: list[str] = []
+    deferrals: list[dict[str, Any]] = []
 
     def parse(raw: str) -> dict[str, Any]:
         target_rows.clear()
         normalizations.clear()
+        deferrals.clear()
         return parse_single_pass_output(
             raw,
             evidence_units=source_units,
@@ -1072,6 +1141,7 @@ def run_single_pass_stage(
             validate_memory=validate_memory,
             target_rows=target_rows,
             normalizations=normalizations,
+            deferrals=deferrals,
         )
 
     def finalize(parsed: dict[str, Any]) -> dict[str, Any]:
@@ -1084,12 +1154,6 @@ def run_single_pass_stage(
         and an unresolvable group is deferred instead of guessed.
         """
 
-        grouped: dict[str, list[str]] = {}
-        for row in target_rows:
-            grouped.setdefault(str(row["target"]), []).append(str(row["candidate_id"]))
-        collisions = {key: ids for key, ids in grouped.items() if len(ids) > 1}
-        if not collisions:
-            return parsed
         items = parsed.get("items")
         if not isinstance(items, list) or not items:
             return parsed
@@ -1098,6 +1162,22 @@ def run_single_pass_stage(
             for index, row in enumerate(items)
             if isinstance(row, Mapping)
         }
+        terminal_ids = {
+            str(row.get("candidate_id"))
+            for row in items
+            if isinstance(row, Mapping) and row.get("decision") in {"UPDATE", "NO_CHANGE"}
+        }
+        grouped: dict[str, list[str]] = {}
+        for row in target_rows:
+            candidate_id = str(row["candidate_id"])
+            if candidate_id not in terminal_ids:
+                # A candidate Core deferred writes nothing, so it cannot
+                # collide with a terminal disposition for the same memory.
+                continue
+            grouped.setdefault(str(row["target"]), []).append(candidate_id)
+        collisions = {key: ids for key, ids in grouped.items() if len(ids) > 1}
+        if not collisions:
+            return parsed
 
         def union_evidence(members: Sequence[Mapping[str, Any]]) -> list[Any]:
             merged: list[Any] = []
@@ -1273,6 +1353,8 @@ def run_single_pass_stage(
             event(repair_context, "parse_accepted_count")
             if normalizations:
                 event(repair_context, "b3_normalization_count", len(normalizations))
+            if deferrals:
+                event(repair_context, "b3_candidate_deferred_count", len(deferrals))
         writer = getattr(model_executor, "_write_model_diagnostic", None)
         if callable(writer):
             try:
@@ -1289,6 +1371,8 @@ def run_single_pass_stage(
         event(primary_context, "parse_accepted_count")
         if normalizations:
             event(primary_context, "b3_normalization_count", len(normalizations))
+        if deferrals:
+            event(primary_context, "b3_candidate_deferred_count", len(deferrals))
     writer = getattr(model_executor, "_write_model_diagnostic", None)
     if callable(writer):
         try:

memleaf-0.2.50/src/memleaf/subprocess_flags.py

@@ -0,0 +1,43 @@
+"""Windows process-creation flags for child processes that must stay invisible.
+
+memleaf starts three kinds of child process: the detached extraction worker,
+host CLI probes, and host model-discovery commands.  None of them owns a
+window, and all of them can be started by a host that has no console of its
+own -- a Hermes desktop process, for example.  On Windows a console program
+started without an explicit flag in that situation gets a brand-new console
+window, which lands on the user's desktop as a stray terminal.
+
+``DETACHED_PROCESS`` looks like the right answer and is not: a console program
+still needs a console, and Windows creates a visible one for it.  Measured on
+Windows 11 with Windows Terminal as the default host, spawning this interpreter
+with ``CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS`` opened one new console
+window whose title was the interpreter path, while ``CREATE_NO_WINDOW`` opened
+none.  ``CREATE_NO_WINDOW`` is therefore used, combined with
+``CREATE_NEW_PROCESS_GROUP`` so the child keeps its own group and is not taken
+down by a Ctrl+C delivered to the parent's console.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+
+
+def hidden_process_flags() -> int:
+    """Return creation flags that keep a console child windowless on Windows."""
+
+    if os.name != "nt":
+        return 0
+    return getattr(subprocess, "CREATE_NO_WINDOW", 0) | getattr(
+        subprocess, "CREATE_NEW_PROCESS_GROUP", 0
+    )
+
+
+def hidden_popen_kwargs() -> dict[str, int]:
+    """Return ``Popen``/``run`` keyword arguments for a windowless child."""
+
+    flags = hidden_process_flags()
+    return {"creationflags": flags} if flags else {}
+
+
+__all__ = ["hidden_popen_kwargs", "hidden_process_flags"]

{memleaf-0.2.48 → memleaf-0.2.50/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.48
+Version: 0.2.50
 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.48。**
+> **版本：0.2.50。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.48 → memleaf-0.2.50}/src/memleaf.egg-info/SOURCES.txt

@@ -77,6 +77,7 @@ src/memleaf/single_pass_memory_planner.py
 src/memleaf/single_pass_plan.py
 src/memleaf/source_policy.py
 src/memleaf/state_layout.py
+src/memleaf/subprocess_flags.py
 src/memleaf/summary_batch.py
 src/memleaf/target_reconciliation.py
 src/memleaf/turn_audit.py