mindforge-memory 6.4.3__tar.gz → 6.4.6__tar.gz

{mindforge_memory-6.4.3/mindforge_memory.egg-info → mindforge_memory-6.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindforge-memory
-Version: 6.4.3
+Version: 6.4.6
 Summary: AI Agent 终身记忆系统 - 四层记忆架构 · 知识图谱 · 多模态支持
 License: MIT
 Project-URL: Homepage, https://github.com/opok-ops/MindForge
@@ -36,11 +36,11 @@ Dynamic: license-file
 
 MindForge gives AI agents a persistent, structured long-term memory: a four-tier lifecycle model, knowledge graphs, hybrid retrieval, end-to-end encryption, and MCP / CLI / REST interfaces. All data stays on your machine.
 
-> **The story** — one developer, seven months, from v1.0 (March 2026) to v6.4.3: no team, no funding, 1,227 passing tests. [Read the journey →](https://opok-ops.github.io/MindForge/#developer)
+> **The story** — one developer, seven months, from v1.0 (March 2026) to v6.4.5: no team, no funding, 1,243 passing tests. [Read the journey →](https://opok-ops.github.io/MindForge/#developer)
 
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-6.4.3-green.svg)](https://github.com/opok-ops/MindForge/releases)
+[![Version](https://img.shields.io/badge/version-6.4.6-green.svg)](https://github.com/opok-ops/MindForge/releases)
 [![Stars](https://img.shields.io/github/stars/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/stargazers)
 [![Forks](https://img.shields.io/github/forks/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/forks)
 [![Open Issues](https://img.shields.io/github/issues/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/issues)
@@ -94,10 +94,26 @@ MindForge search "what does user like"
 MindForge stats
 ```
 
+
+## Scale & Quality Benchmarks (v6.4.6, measured)
+
+| Scale | add throughput | search p50 (rare token) | search p50 (realistic mixed) | db size |
+|---|---|---|---|---|
+| 200 entries (baseline) | — | 1.8 ms | — | <1 MB |
+| 10,000 | 1,080/s | ~9.5 ms | ~16 ms | 10 MB |
+| 100,000 | ~558/s | 7.4 ms | 143 ms | 98 MB |
+
+- Retrieval quality (fixed-seed, `benchmarks/quality_bench.py`, 2k entries): needle Recall@1 = 1.0, MRR = 1.0, topic Recall@1 = 1.0, noise false-recall = 0.
+- Known characteristic: all-common-word queries on synthetic template data fall back to O(N) scan (documented, not a defect); realistic queries hit the pruned inverted index.
+- Full LLM-judged benchmarks (LoCoMo / LongMemEval) — interface ready, not yet run (requires external LLM API key).
+- TF-IDF degraded mode process memory at 100k: ~700 MB. Index LRU cap: 100,000 docs (MINDFORGE_INDEX_MAX_DOCS).
+
 ## What's New
 
-v6.1.3 – v6.4.3 shipped in ten days (2026-11-01 → 11-10), guarded by **1,228 tests** (1,227 passing, 1 environment-skipped).
+v6.1.3 – v6.4.5 shipped in ten days (2026-11-01 → 11-10; two same-day releases), guarded by **1,244 tests** (1,243 passing, 1 environment-skipped).
 
+- **v6.4.6 — scale validation & retrieval benchmarks** (2026-11-10). First 100,000-entry stress test: add throughput ~600/s (linear), ~98MB db, memory peak ~700MB (TF-IDF degraded mode), search p50 7.4ms (rare token, −92% vs pre-fix) / 143ms (realistic mixed); pathological all-common query 421→218ms (−48%). Fixed a real bottleneck found by the stress test: Chinese long-query p50 was 421ms — profile showed low-IDF common words degenerating the inverted index into full-corpus scans. Fix: two-tier pruning (relative-eps + standard IR max_df stop-wording for df > 0.5×N) + heapq.nlargest; pathological all-common-word queries (synthetic-template data only) honestly documented as known O(N) characteristic, realistic queries verified unaffected (8k A/B, 30k side-by-side: 43ms mixed vs 86ms pathological). Shipped reproducible benchmarks (`benchmarks/scale_bench.py`, `benchmarks/quality_bench.py`): needle Recall@1 = 1.0 / MRR = 1.0, zero noise false-recall. Full LLM-judged benchmarks (LoCoMo/LongMemEval) deferred — needs external LLM API key. 7 new guards.
+- **v6.4.5 — audit-driven fixes** (2026-11-10; v6.4.4 skipped by maintainer decision). Two inverse doc-code inconsistencies (v6.4.3 fixed "claimed but not done"; this one fixes "done but not tracked"): `connectors.py` outgoing HTTP User-Agent was hardcoded `MindForge-Connector/5.8.9` — lying about the version to every target site since the 5.8.9 era (`event_bus.py` fixed the same disease in v5.6.8; this one slipped through). Now dynamic from the single version truth. Website "core modules" count was stale (17 in prose, 15 in stat card, 31 measured) — both fixed to the measured 31; MCP tool count 87 verified exact, untouched. Audit archive (not a defect): WAL auto-checkpoint verified healthy under daemon-like load — 4 rounds × 400 mixed ops, WAL converged at ~4.1MB (default 1000-page threshold), TRUNCATE resets to zero. 5 new guards in `tests/test_v645_fixes.py`.
 - **v6.4.3 — documentation-code consistency fix** (2026-11-10). Pre-release audit found that v6.4.2's claimed first cut — WAL + `synchronous=NORMAL` — **never landed in code**: `_get_conn()` set only `journal_mode=WAL`, leaving `synchronous` at SQLite's default FULL. The 2.1× search gain was real, but carried entirely by the other four cuts — real numbers, misattributed cause. This release adds `PRAGMA synchronous=NORMAL` on the WAL branch (per-connection, cross-thread; network-FS DELETE fallback stays FULL by design). Same-machine A/B on SSD shows no statistically significant latency delta (search p50 1.8 → 1.8ms — fsync is ~0.1ms-scale here); the benefit targets slow disks and IO-saturated containers, and more importantly makes the documented power-loss semantics (un-checkpointed access counts / search audits may be lost; compliance audits still commit immediately) actually hold. 4 new guard tests in `tests/test_v643_fixes.py`.
 - **v6.4.2 — tens-of-thousands-chars latency: another 2×** (2026-11-09). Same-machine A/B benchmark (400 memories / ~47k chars, 3 runs each): **search p50 6.3→3.0ms (2.1×), p95 11.7→4.2ms (2.8×)**; 24k-char library p50 2.5ms; fast machine state 1.8ms. Five surgical cuts: WAL + `synchronous=NORMAL` (commits skip per-write fsync), enum-downgrade memo, `row.keys()` set reuse, first-visit access-count batching merged into one `flush_access()` transaction per search, and search-audit INSERT folded into the same commit. The v5.6.3 throttle contract and v5.5.4 `recently_accessed` semantics are pinned by 23 contract tests — all green. Compliance-grade audits still commit immediately. *(Note: the `synchronous=NORMAL` cut landed in v6.4.3 — see above.)*
 - **v6.4.1 — million-character millisecond search** (2026-11-09). Scale benchmark (8,000 memories / ~990k chars) exposed a fuzzy-fallback long tail: search p95 881ms. Root causes: SequenceMatcher wasted on mathematically-impossible matches (ratio = 2M/(m+n), M ≤ m, so n ≥ 4m can never pass 0.4) + a ~50μs/entry Python full-scan tax. Fixed with a math-capped prune + SQLite-level candidate pre-filtering: **search p95 881→30.7ms (28×)**, add p50 2.6ms flat at 10k-scale. New `scripts/bench_scale.py` + CI scale guard (3000 memories, millisecond contract) + 4 behavior-level regression tests pin the semantics.
@@ -167,7 +183,7 @@ v6.1.3 – v6.4.3 shipped in ten days (2026-11-01 → 11-10), guarded by **1,228
 
 ```
 ┌──────────────────────────────────────────────────────┐
-│           MindForge v6.4.3            │
+│           MindForge v6.4.6            │
 │  Cognitive Layer  Personality · KnowledgeGraph       │
 │                   MemoryEvolution · FederatedMemory  │
 ├──────────────────────────────────────────────────────┤

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/README.md

@@ -6,11 +6,11 @@
 
 MindForge gives AI agents a persistent, structured long-term memory: a four-tier lifecycle model, knowledge graphs, hybrid retrieval, end-to-end encryption, and MCP / CLI / REST interfaces. All data stays on your machine.
 
-> **The story** — one developer, seven months, from v1.0 (March 2026) to v6.4.3: no team, no funding, 1,227 passing tests. [Read the journey →](https://opok-ops.github.io/MindForge/#developer)
+> **The story** — one developer, seven months, from v1.0 (March 2026) to v6.4.5: no team, no funding, 1,243 passing tests. [Read the journey →](https://opok-ops.github.io/MindForge/#developer)
 
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-6.4.3-green.svg)](https://github.com/opok-ops/MindForge/releases)
+[![Version](https://img.shields.io/badge/version-6.4.6-green.svg)](https://github.com/opok-ops/MindForge/releases)
 [![Stars](https://img.shields.io/github/stars/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/stargazers)
 [![Forks](https://img.shields.io/github/forks/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/forks)
 [![Open Issues](https://img.shields.io/github/issues/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/issues)
@@ -64,10 +64,26 @@ MindForge search "what does user like"
 MindForge stats
 ```
 
+
+## Scale & Quality Benchmarks (v6.4.6, measured)
+
+| Scale | add throughput | search p50 (rare token) | search p50 (realistic mixed) | db size |
+|---|---|---|---|---|
+| 200 entries (baseline) | — | 1.8 ms | — | <1 MB |
+| 10,000 | 1,080/s | ~9.5 ms | ~16 ms | 10 MB |
+| 100,000 | ~558/s | 7.4 ms | 143 ms | 98 MB |
+
+- Retrieval quality (fixed-seed, `benchmarks/quality_bench.py`, 2k entries): needle Recall@1 = 1.0, MRR = 1.0, topic Recall@1 = 1.0, noise false-recall = 0.
+- Known characteristic: all-common-word queries on synthetic template data fall back to O(N) scan (documented, not a defect); realistic queries hit the pruned inverted index.
+- Full LLM-judged benchmarks (LoCoMo / LongMemEval) — interface ready, not yet run (requires external LLM API key).
+- TF-IDF degraded mode process memory at 100k: ~700 MB. Index LRU cap: 100,000 docs (MINDFORGE_INDEX_MAX_DOCS).
+
 ## What's New
 
-v6.1.3 – v6.4.3 shipped in ten days (2026-11-01 → 11-10), guarded by **1,228 tests** (1,227 passing, 1 environment-skipped).
+v6.1.3 – v6.4.5 shipped in ten days (2026-11-01 → 11-10; two same-day releases), guarded by **1,244 tests** (1,243 passing, 1 environment-skipped).
 
+- **v6.4.6 — scale validation & retrieval benchmarks** (2026-11-10). First 100,000-entry stress test: add throughput ~600/s (linear), ~98MB db, memory peak ~700MB (TF-IDF degraded mode), search p50 7.4ms (rare token, −92% vs pre-fix) / 143ms (realistic mixed); pathological all-common query 421→218ms (−48%). Fixed a real bottleneck found by the stress test: Chinese long-query p50 was 421ms — profile showed low-IDF common words degenerating the inverted index into full-corpus scans. Fix: two-tier pruning (relative-eps + standard IR max_df stop-wording for df > 0.5×N) + heapq.nlargest; pathological all-common-word queries (synthetic-template data only) honestly documented as known O(N) characteristic, realistic queries verified unaffected (8k A/B, 30k side-by-side: 43ms mixed vs 86ms pathological). Shipped reproducible benchmarks (`benchmarks/scale_bench.py`, `benchmarks/quality_bench.py`): needle Recall@1 = 1.0 / MRR = 1.0, zero noise false-recall. Full LLM-judged benchmarks (LoCoMo/LongMemEval) deferred — needs external LLM API key. 7 new guards.
+- **v6.4.5 — audit-driven fixes** (2026-11-10; v6.4.4 skipped by maintainer decision). Two inverse doc-code inconsistencies (v6.4.3 fixed "claimed but not done"; this one fixes "done but not tracked"): `connectors.py` outgoing HTTP User-Agent was hardcoded `MindForge-Connector/5.8.9` — lying about the version to every target site since the 5.8.9 era (`event_bus.py` fixed the same disease in v5.6.8; this one slipped through). Now dynamic from the single version truth. Website "core modules" count was stale (17 in prose, 15 in stat card, 31 measured) — both fixed to the measured 31; MCP tool count 87 verified exact, untouched. Audit archive (not a defect): WAL auto-checkpoint verified healthy under daemon-like load — 4 rounds × 400 mixed ops, WAL converged at ~4.1MB (default 1000-page threshold), TRUNCATE resets to zero. 5 new guards in `tests/test_v645_fixes.py`.
 - **v6.4.3 — documentation-code consistency fix** (2026-11-10). Pre-release audit found that v6.4.2's claimed first cut — WAL + `synchronous=NORMAL` — **never landed in code**: `_get_conn()` set only `journal_mode=WAL`, leaving `synchronous` at SQLite's default FULL. The 2.1× search gain was real, but carried entirely by the other four cuts — real numbers, misattributed cause. This release adds `PRAGMA synchronous=NORMAL` on the WAL branch (per-connection, cross-thread; network-FS DELETE fallback stays FULL by design). Same-machine A/B on SSD shows no statistically significant latency delta (search p50 1.8 → 1.8ms — fsync is ~0.1ms-scale here); the benefit targets slow disks and IO-saturated containers, and more importantly makes the documented power-loss semantics (un-checkpointed access counts / search audits may be lost; compliance audits still commit immediately) actually hold. 4 new guard tests in `tests/test_v643_fixes.py`.
 - **v6.4.2 — tens-of-thousands-chars latency: another 2×** (2026-11-09). Same-machine A/B benchmark (400 memories / ~47k chars, 3 runs each): **search p50 6.3→3.0ms (2.1×), p95 11.7→4.2ms (2.8×)**; 24k-char library p50 2.5ms; fast machine state 1.8ms. Five surgical cuts: WAL + `synchronous=NORMAL` (commits skip per-write fsync), enum-downgrade memo, `row.keys()` set reuse, first-visit access-count batching merged into one `flush_access()` transaction per search, and search-audit INSERT folded into the same commit. The v5.6.3 throttle contract and v5.5.4 `recently_accessed` semantics are pinned by 23 contract tests — all green. Compliance-grade audits still commit immediately. *(Note: the `synchronous=NORMAL` cut landed in v6.4.3 — see above.)*
 - **v6.4.1 — million-character millisecond search** (2026-11-09). Scale benchmark (8,000 memories / ~990k chars) exposed a fuzzy-fallback long tail: search p95 881ms. Root causes: SequenceMatcher wasted on mathematically-impossible matches (ratio = 2M/(m+n), M ≤ m, so n ≥ 4m can never pass 0.4) + a ~50μs/entry Python full-scan tax. Fixed with a math-capped prune + SQLite-level candidate pre-filtering: **search p95 881→30.7ms (28×)**, add p50 2.6ms flat at 10k-scale. New `scripts/bench_scale.py` + CI scale guard (3000 memories, millisecond contract) + 4 behavior-level regression tests pin the semantics.
@@ -137,7 +153,7 @@ v6.1.3 – v6.4.3 shipped in ten days (2026-11-01 → 11-10), guarded by **1,228
 
 ```
 ┌──────────────────────────────────────────────────────┐
-│           MindForge v6.4.3            │
+│           MindForge v6.4.6            │
 │  Cognitive Layer  Personality · KnowledgeGraph       │
 │                   MemoryEvolution · FederatedMemory  │
 ├──────────────────────────────────────────────────────┤

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/mindforge/core/indexer.py

@@ -3,6 +3,7 @@ MindForge v5.0 索引引擎
 支持 TF-IDF、向量索引、FTS5 全文检索
 """
 
+import heapq
 import math
 import os
 import re
@@ -151,17 +152,35 @@ class VectorIndex:
         if query_norm == 0:
             return [(doc_id, 0.0) for doc_id in list(self.vectors.keys())[:top_k]]
 
+        # v6.4.6 perf: 低区分度查询维剪枝。100k 规模压测发现中文长查询
+        # p50 421ms，profile 定位到常见词（如「条目/陈述性/记忆」）的倒排
+        # 链全量遍历。两层剪枝：eps 相对阈值 + max_df 停用词（df > 0.5×N
+        # 的维是平滑 IDF 下 qval≈tf×1 的全库词——遍历整条链却无区分度，
+        # 所有文档点积同加近似常数，top-K 排序不变；30k profile 实证
+        # eps 剪不掉全库词，必须按链长剪）。
+        _EPS_REL = 0.02
+        _half = 0.5 * len(self.vectors)
+        active = [(idx, qval) for idx, qval in q.items()
+                  if qval > _EPS_REL * query_norm
+                  and len(self._postings.get(idx, ())) <= _half]
+        if not active:
+            # 全部维度被剪（极端退化查询）：退回原语义，保证不空召回
+            active = list(q.items())
+
         # 倒排链累加点积：只访问与查询共享非零维度的候选文档
         dots: Dict[str, float] = {}
-        for idx, qval in q.items():
+        for idx, qval in active:
             for doc_id, dval in self._postings.get(idx, {}).items():
                 dots[doc_id] = dots.get(doc_id, 0.0) + qval * dval
 
-        scores = [(doc_id, dot / (query_norm * self._norms[doc_id]))
-                  for doc_id, dot in dots.items()
-                  if self._norms.get(doc_id, 0.0) > 0]
-        scores.sort(key=lambda x: x[1], reverse=True)
-        return scores[:top_k]
+        # v6.4.6 perf: heapq.nlargest 替代全量 sort——候选集大时
+        # O(n·log k) 优于 O(n·log n)，且免建全量列表排序的中间开销。
+        return heapq.nlargest(
+            top_k,
+            ((doc_id, dot / (query_norm * self._norms[doc_id]))
+             for doc_id, dot in dots.items()
+             if self._norms.get(doc_id, 0.0) > 0),
+            key=lambda x: x[1])
 
     def _cosine(self, v1, v2) -> float:
         """保留原始接口（向后兼容），稀疏/稠密输入均支持"""

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/mindforge/core/mindforge.py

@@ -1230,6 +1230,20 @@ class MindForge:
         # v5.6.2 安全修复：隐私访问控制
         entry = self._storage.get_memory(memory_id, actor, session_id)
         if entry is None:
+            # v6.4.6 fix: 硬删已软删（trash）条目的数据主权路径。get_memory
+            # 过滤 trash 条目，此前 delete(hard_delete=True) 对回收站内容
+            # 静默返回 False（CLI 显示「记忆不存在」，误导用户以为已彻底
+            # 清除，物理数据实际仍在库中）。GDPR erase 语义（storage 权利
+            # 清单 2122 行）要求：能软删活条目，就必须能物理清除其 trash
+            # 态。隐私读检查不适用此分支——内容已在 trash，仅物理清除；
+            # storage.delete_memory 自带审计写入（v5.6.1 同事务）。
+            if hard_delete:
+                if self._storage.is_in_trash(memory_id):
+                    success = self._storage.delete_memory(
+                        memory_id, actor, session_id, hard_delete=True)
+                    if success:
+                        self._index.remove_memory(memory_id)
+                    return success
             return False
         ok, _reason = self.privacy_engine.check_access(entry, actor, session_id)
         if not ok:

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/mindforge/core/storage.py

@@ -2959,6 +2959,20 @@ class StorageEngine:
         return len(ids)
 
     @_with_rollback
+    def is_in_trash(self, entry_id: str) -> bool:
+        """v6.4.6: 判定条目是否处于回收站（软删态）。
+
+        服务 delete(hard_delete=True) 的数据主权路径：get_memory 过滤
+        trash 条目（WHERE category != 'trash'），上层 None 分支需要此
+        轻量查询放行物理清除。幂等，只读，不产生任何写副作用。
+        """
+        conn = self._get_conn()
+        row = conn.execute(
+            "SELECT 1 FROM memories WHERE id = ? AND category = 'trash'",
+            (entry_id,),
+        ).fetchone()
+        return row is not None
+
     def delete_memory(self, entry_id: str,
                       actor: str = "", session_id: str = "",
                       hard_delete: bool = False) -> bool:

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/mindforge/core/version.py

@@ -20,10 +20,10 @@ core/mindforge.py、cli/main.py、mcp/server.py），每处都带一份硬编码
 from typing import Tuple
 
 #: 当前发布版本（唯一真值）
-__version__: str = "6.4.3"
+__version__: str = "6.4.6"
 
 #: 结构化版本元组，便于比较（如 `VERSION_INFO >= (6, 1, 0)`）
-VERSION_INFO: Tuple[int, int, int] = (6, 4, 3)
+VERSION_INFO: Tuple[int, int, int] = (6, 4, 6)
 
 #: 下一个大版本的目标版本号（供 v6 端口预留引用）
 NEXT_MAJOR_TARGET: str = "7.0.0"

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/mindforge/modules/connectors.py

@@ -18,6 +18,10 @@ import ipaddress
 import ssl
 import urllib.parse
 import urllib.request
+
+# v6.4.5: User-Agent 版本动态化（唯一真值 mindforge/core/version.py）。
+# version.py 仅依赖 typing，无循环导入风险。
+from mindforge.core.version import __version__
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Type
 
@@ -308,7 +312,11 @@ class UrlConnector(BaseConnector):
             _FixedIPHTTPSHandler(fixed_ip),
         )
         req = urllib.request.Request(
-            source, headers={"User-Agent": "MindForge-Connector/5.8.9"})
+            # v6.4.5 fix: 此前硬编码 "MindForge-Connector/5.8.9"（5.8.9 时代
+            # 写死后再未跟上），对外请求谎报版本。改为动态引用唯一真值
+            # mindforge/core/version.py（与 event_bus.py / cli URL Importer
+            # 同款模式，v5.6.8 起已验证）。
+            source, headers={"User-Agent": f"MindForge-Connector/{__version__}"})
         with opener.open(req, timeout=kwargs.get("timeout", 15)) as resp:
             content_type = resp.headers.get("Content-Type", "")
             data = _read_limited(resp)

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6/mindforge_memory.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindforge-memory
-Version: 6.4.3
+Version: 6.4.6
 Summary: AI Agent 终身记忆系统 - 四层记忆架构 · 知识图谱 · 多模态支持
 License: MIT
 Project-URL: Homepage, https://github.com/opok-ops/MindForge
@@ -36,11 +36,11 @@ Dynamic: license-file
 
 MindForge gives AI agents a persistent, structured long-term memory: a four-tier lifecycle model, knowledge graphs, hybrid retrieval, end-to-end encryption, and MCP / CLI / REST interfaces. All data stays on your machine.
 
-> **The story** — one developer, seven months, from v1.0 (March 2026) to v6.4.3: no team, no funding, 1,227 passing tests. [Read the journey →](https://opok-ops.github.io/MindForge/#developer)
+> **The story** — one developer, seven months, from v1.0 (March 2026) to v6.4.5: no team, no funding, 1,243 passing tests. [Read the journey →](https://opok-ops.github.io/MindForge/#developer)
 
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-6.4.3-green.svg)](https://github.com/opok-ops/MindForge/releases)
+[![Version](https://img.shields.io/badge/version-6.4.6-green.svg)](https://github.com/opok-ops/MindForge/releases)
 [![Stars](https://img.shields.io/github/stars/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/stargazers)
 [![Forks](https://img.shields.io/github/forks/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/forks)
 [![Open Issues](https://img.shields.io/github/issues/opok-ops/MindForge.svg)](https://github.com/opok-ops/MindForge/issues)
@@ -94,10 +94,26 @@ MindForge search "what does user like"
 MindForge stats
 ```
 
+
+## Scale & Quality Benchmarks (v6.4.6, measured)
+
+| Scale | add throughput | search p50 (rare token) | search p50 (realistic mixed) | db size |
+|---|---|---|---|---|
+| 200 entries (baseline) | — | 1.8 ms | — | <1 MB |
+| 10,000 | 1,080/s | ~9.5 ms | ~16 ms | 10 MB |
+| 100,000 | ~558/s | 7.4 ms | 143 ms | 98 MB |
+
+- Retrieval quality (fixed-seed, `benchmarks/quality_bench.py`, 2k entries): needle Recall@1 = 1.0, MRR = 1.0, topic Recall@1 = 1.0, noise false-recall = 0.
+- Known characteristic: all-common-word queries on synthetic template data fall back to O(N) scan (documented, not a defect); realistic queries hit the pruned inverted index.
+- Full LLM-judged benchmarks (LoCoMo / LongMemEval) — interface ready, not yet run (requires external LLM API key).
+- TF-IDF degraded mode process memory at 100k: ~700 MB. Index LRU cap: 100,000 docs (MINDFORGE_INDEX_MAX_DOCS).
+
 ## What's New
 
-v6.1.3 – v6.4.3 shipped in ten days (2026-11-01 → 11-10), guarded by **1,228 tests** (1,227 passing, 1 environment-skipped).
+v6.1.3 – v6.4.5 shipped in ten days (2026-11-01 → 11-10; two same-day releases), guarded by **1,244 tests** (1,243 passing, 1 environment-skipped).
 
+- **v6.4.6 — scale validation & retrieval benchmarks** (2026-11-10). First 100,000-entry stress test: add throughput ~600/s (linear), ~98MB db, memory peak ~700MB (TF-IDF degraded mode), search p50 7.4ms (rare token, −92% vs pre-fix) / 143ms (realistic mixed); pathological all-common query 421→218ms (−48%). Fixed a real bottleneck found by the stress test: Chinese long-query p50 was 421ms — profile showed low-IDF common words degenerating the inverted index into full-corpus scans. Fix: two-tier pruning (relative-eps + standard IR max_df stop-wording for df > 0.5×N) + heapq.nlargest; pathological all-common-word queries (synthetic-template data only) honestly documented as known O(N) characteristic, realistic queries verified unaffected (8k A/B, 30k side-by-side: 43ms mixed vs 86ms pathological). Shipped reproducible benchmarks (`benchmarks/scale_bench.py`, `benchmarks/quality_bench.py`): needle Recall@1 = 1.0 / MRR = 1.0, zero noise false-recall. Full LLM-judged benchmarks (LoCoMo/LongMemEval) deferred — needs external LLM API key. 7 new guards.
+- **v6.4.5 — audit-driven fixes** (2026-11-10; v6.4.4 skipped by maintainer decision). Two inverse doc-code inconsistencies (v6.4.3 fixed "claimed but not done"; this one fixes "done but not tracked"): `connectors.py` outgoing HTTP User-Agent was hardcoded `MindForge-Connector/5.8.9` — lying about the version to every target site since the 5.8.9 era (`event_bus.py` fixed the same disease in v5.6.8; this one slipped through). Now dynamic from the single version truth. Website "core modules" count was stale (17 in prose, 15 in stat card, 31 measured) — both fixed to the measured 31; MCP tool count 87 verified exact, untouched. Audit archive (not a defect): WAL auto-checkpoint verified healthy under daemon-like load — 4 rounds × 400 mixed ops, WAL converged at ~4.1MB (default 1000-page threshold), TRUNCATE resets to zero. 5 new guards in `tests/test_v645_fixes.py`.
 - **v6.4.3 — documentation-code consistency fix** (2026-11-10). Pre-release audit found that v6.4.2's claimed first cut — WAL + `synchronous=NORMAL` — **never landed in code**: `_get_conn()` set only `journal_mode=WAL`, leaving `synchronous` at SQLite's default FULL. The 2.1× search gain was real, but carried entirely by the other four cuts — real numbers, misattributed cause. This release adds `PRAGMA synchronous=NORMAL` on the WAL branch (per-connection, cross-thread; network-FS DELETE fallback stays FULL by design). Same-machine A/B on SSD shows no statistically significant latency delta (search p50 1.8 → 1.8ms — fsync is ~0.1ms-scale here); the benefit targets slow disks and IO-saturated containers, and more importantly makes the documented power-loss semantics (un-checkpointed access counts / search audits may be lost; compliance audits still commit immediately) actually hold. 4 new guard tests in `tests/test_v643_fixes.py`.
 - **v6.4.2 — tens-of-thousands-chars latency: another 2×** (2026-11-09). Same-machine A/B benchmark (400 memories / ~47k chars, 3 runs each): **search p50 6.3→3.0ms (2.1×), p95 11.7→4.2ms (2.8×)**; 24k-char library p50 2.5ms; fast machine state 1.8ms. Five surgical cuts: WAL + `synchronous=NORMAL` (commits skip per-write fsync), enum-downgrade memo, `row.keys()` set reuse, first-visit access-count batching merged into one `flush_access()` transaction per search, and search-audit INSERT folded into the same commit. The v5.6.3 throttle contract and v5.5.4 `recently_accessed` semantics are pinned by 23 contract tests — all green. Compliance-grade audits still commit immediately. *(Note: the `synchronous=NORMAL` cut landed in v6.4.3 — see above.)*
 - **v6.4.1 — million-character millisecond search** (2026-11-09). Scale benchmark (8,000 memories / ~990k chars) exposed a fuzzy-fallback long tail: search p95 881ms. Root causes: SequenceMatcher wasted on mathematically-impossible matches (ratio = 2M/(m+n), M ≤ m, so n ≥ 4m can never pass 0.4) + a ~50μs/entry Python full-scan tax. Fixed with a math-capped prune + SQLite-level candidate pre-filtering: **search p95 881→30.7ms (28×)**, add p50 2.6ms flat at 10k-scale. New `scripts/bench_scale.py` + CI scale guard (3000 memories, millisecond contract) + 4 behavior-level regression tests pin the semantics.
@@ -167,7 +183,7 @@ v6.1.3 – v6.4.3 shipped in ten days (2026-11-01 → 11-10), guarded by **1,228
 
 ```
 ┌──────────────────────────────────────────────────────┐
-│           MindForge v6.4.3            │
+│           MindForge v6.4.6            │
 │  Cognitive Layer  Personality · KnowledgeGraph       │
 │                   MemoryEvolution · FederatedMemory  │
 ├──────────────────────────────────────────────────────┤

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/mindforge_memory.egg-info/SOURCES.txt

@@ -68,6 +68,7 @@ mindforge_memory.egg-info/requires.txt
 mindforge_memory.egg-info/top_level.txt
 tests/test_core.py
 tests/test_security_hardening.py
+tests/test_trash_hard_delete.py
 tests/test_v546_features.py
 tests/test_v547_fixes.py
 tests/test_v548_features.py
@@ -132,4 +133,6 @@ tests/test_v635_features.py
 tests/test_v635_integration.py
 tests/test_v636_fixes.py
 tests/test_v643_fixes.py
+tests/test_v645_fixes.py
+tests/test_v646_fixes.py
 tests/test_v6_ports.py

mindforge_memory-6.4.6/tests/test_trash_hard_delete.py

@@ -0,0 +1,115 @@
+"""
+回收站硬删数据主权守卫（2026-11-10 数据/安全专项审计发现）
+
+缺陷形态：MindForge.delete(id, hard_delete=True) 对已软删（trash 态）
+条目静默返回 False——get_memory 过滤 trash（WHERE category != 'trash'），
+上层 None 分支直接拒绝，CLI 对用户显示「记忆不存在」。物理数据仍在
+库中，误导用户以为已彻底清除。GDPR erase 语义（storage 权利清单）
+要求：能软删活条目，就必须能物理清除其 trash 态。
+
+修复：delete() None 分支 + hard_delete 时查 is_in_trash 放行物理清除
+（隐私读检查不适用：内容已在 trash，仅物理清除；审计仍同事务写入）。
+
+对照组语义（不得回归）：
+- 活条目正常软删/硬删路径不变；
+- 对 trash 条目软删（重复软删）仍返回 False；
+- 不存在的 id 一切删除返回 False。
+"""
+
+import os
+import sys
+import shutil
+import sqlite3
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from mindforge import MindForge
+from mindforge.core.types import MemoryConfig
+
+
+def _mk(tmp):
+    mf = MindForge(config=MemoryConfig(
+        db_path=os.path.join(tmp, "m.db"), key_file=None, encrypted=False))
+    mf.add("守卫探针 alpha-key-1 活条目")
+    mf.add("守卫探针 beta-key-2 待删条目")
+    raw = sqlite3.connect(os.path.join(tmp, "m.db"))
+    # memories.id 是 UUID（无序），必须按内容锚定——SELECT 顺序映射会让
+    # aid/bid 张冠李戴（本文件首次编写即踩此坑，ghost 断言假失败）。
+    aid = raw.execute(
+        "SELECT id FROM memories WHERE content LIKE '%alpha%'").fetchone()[0]
+    bid = raw.execute(
+        "SELECT id FROM memories WHERE content LIKE '%beta%'").fetchone()[0]
+    raw.close()
+    return mf, (aid, bid)
+
+
+class TestTrashHardDelete(unittest.TestCase):
+
+    def test_hard_delete_soft_deleted_entry(self):
+        """核心：软删后 hard_delete 必须物理清除（此前静默 False）。"""
+        tmp = tempfile.mkdtemp(prefix="mf_thd_")
+        try:
+            mf, (aid, bid) = _mk(tmp)
+            self.assertTrue(mf.delete(bid))                       # 软删
+            self.assertIsNone(mf.get(bid))                        # trash 被 get 过滤
+            self.assertTrue(mf.delete(bid, hard_delete=True))     # ← 修复点
+            raw = sqlite3.connect(os.path.join(tmp, "m.db"))
+            rows = raw.execute(
+                "SELECT count(*) FROM memories WHERE id = ?", (bid,)).fetchone()[0]
+            fts = raw.execute("SELECT count(*) FROM memory_fts").fetchone()[0]
+            raw.close()
+            self.assertEqual(rows, 0, "trash 条目未被物理清除")
+            self.assertEqual(fts, 1, "FTS 未同步（应只剩活条目）")
+            self.assertEqual(len(mf.search("alpha-key-1").chunks), 1)
+            # 注意：不能断言 search("beta-key-2") chunks==0——fuzzy 宽召回
+            # 会把相近活条目（alpha）召回给 beta 查询（tfidf+fuzzy 策略设计）。
+            # 正确断言：召回内容中不含已物理删除的 beta 内容（无幽灵）。
+            ghost = [c for c in mf.search("beta-key-2").chunks
+                     if "beta-key-2" in getattr(c, "content", "")]
+            self.assertEqual(len(ghost), 0, "已物理删除内容被召回（真幽灵）")
+            mf.close()
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+
+    def test_soft_delete_on_trash_still_false(self):
+        """对照：对 trash 条目再软删仍 False（重复软删无意义）。"""
+        tmp = tempfile.mkdtemp(prefix="mf_thd2_")
+        try:
+            mf, (aid, bid) = _mk(tmp)
+            mf.delete(bid)
+            self.assertFalse(mf.delete(bid))   # 软删 trash = False
+            mf.close()
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+
+    def test_nonexistent_id_hard_delete_false(self):
+        """对照：不存在 id 一切删除 False（不因修复误报成功）。"""
+        tmp = tempfile.mkdtemp(prefix="mf_thd3_")
+        try:
+            mf, (aid, bid) = _mk(tmp)
+            self.assertFalse(mf.delete("ghost-id-404", hard_delete=True))
+            self.assertFalse(mf.delete("ghost-id-404"))
+            mf.close()
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+
+    def test_is_in_trash_query(self):
+        """storage.is_in_trash 三态：活条目 False / 软删后 True / 物理删后 False。"""
+        tmp = tempfile.mkdtemp(prefix="mf_thd4_")
+        try:
+            mf, (aid, bid) = _mk(tmp)
+            st = mf._storage
+            self.assertFalse(st.is_in_trash(bid))
+            mf.delete(bid)
+            self.assertTrue(st.is_in_trash(bid))
+            mf.delete(bid, hard_delete=True)
+            self.assertFalse(st.is_in_trash(bid))
+            mf.close()
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/tests/test_v568_fixes.py

@@ -39,7 +39,7 @@ import mindforge.core.version as core_version
 
 
 _REPO = Path(__file__).resolve().parent.parent
-_EXPECTED_VERSION = "6.4.3"
+_EXPECTED_VERSION = "6.4.6"
 
 # 本轮修复涉及的、必须与 mindforge/core/version.py 保持一致的源码文件
 _VERSION_TRUTH_FILES = (

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/tests/test_v575_release_consistency.py

@@ -40,8 +40,8 @@ class TestVersionTruth(unittest.TestCase):
     def test_core_version_matches_release(self):
         # 版本推进时必须一并更新此处的钉值（与 test_v568_fixes 的
         # _EXPECTED_VERSION 同一约定：让「忘记 bump 版本」在测试里显形）。
-        self.assertEqual(core_version.__version__, "6.4.3")
-        self.assertEqual(core_version.VERSION_INFO, (6, 4, 3))
+        self.assertEqual(core_version.__version__, "6.4.6")
+        self.assertEqual(core_version.VERSION_INFO, (6, 4, 6))
 
     def test_pyproject_matches_core_version(self):
         # v5.8.13 起 pyproject 不再写死静态版本：

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/tests/test_v612_fixes.py

@@ -662,8 +662,8 @@ class TestVersionConsistency(unittest.TestCase):
     def test_version_is_612(self):
         from mindforge.core.version import VERSION_INFO, __version__
         # v6.1.3：版本钉值随发版推进更新（历史方法名保留）
-        self.assertEqual(__version__, "6.4.3")
-        self.assertEqual(VERSION_INFO, (6, 4, 3))
+        self.assertEqual(__version__, "6.4.6")
+        self.assertEqual(VERSION_INFO, (6, 4, 6))
 
     def test_json_round_trip_safety_of_preview(self):
         """save_evolution 的预览序列化不得抛（不可 json 化的对象走 str 兜底）。"""

{mindforge_memory-6.4.3 → mindforge_memory-6.4.6}/tests/test_v643_fixes.py

@@ -89,10 +89,12 @@ class TestSynchronousNormalGuard(_WALCase):
 
 
 class TestVersionBump(unittest.TestCase):
-    """版本钉值：忘记 bump 时在此显形（与 v568/v575/v612 守卫同一约定）。"""
+    """版本钉值：忘记 bump 时在此显形（与 v568/v575/v612 守卫同一约定）。
+    v6.4.5 教训：每版 fixes 文件的版本断言在后续发版都要一并 bump——
+    钉点集合随版本数递增，发版链清单必须扫全部 test_v*fixes.py。"""
 
-    def test_version_is_643(self):
-        self.assertEqual(__version__, "6.4.3")
+    def test_version_is_current(self):
+        self.assertEqual(__version__, "6.4.6")
 
 
 if __name__ == "__main__":

mindforge_memory-6.4.6/tests/test_v645_fixes.py

@@ -0,0 +1,108 @@
+"""
+MindForge v6.4.5 回归测试
+
+覆盖发版前审计发现的两类缺陷（2026-11-10）：
+
+  - Bug-A（P1）: connectors.py 对外请求的 User-Agent 硬编码为
+    "MindForge-Connector/5.8.9"——5.8.9 时代写死后未跟上，v6.x 连发
+    20+ 版本一直在对外谎报版本（event_bus.py v5.6.8 修过同款病，
+    此处漏网）。修复：动态引用 mindforge/core/version.py 唯一真值。
+  - Bug-B（P2，数据过时）: 官网「核心模块」数正文 17 / 统计卡 15，
+    实测 mindforge/modules/ 为 31 个模块文件——两处口径双双过时且
+    互相矛盾。修正为实测 31，并由本守卫钉住（website 数字必须等于
+    modules/ 实测文件数，防再漂移）。
+
+审计存档（非缺陷）：WAL auto-checkpoint 行为验证——四轮 × 400 次
+混合操作（add+search），WAL 稳定收敛于 ~4.1MB（默认 1000 页阈值），
+无无限膨胀；主动 TRUNCATE 可归零。daemon 长连接场景健康。
+"""
+
+import os
+import re
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+_REPO = Path(__file__).resolve().parent.parent
+
+from mindforge.core.version import __version__
+
+
+class TestUserAgentVersionTruth(unittest.TestCase):
+    """对外 User-Agent 的版本必须动态引用唯一真值，不得硬编码。"""
+
+    def test_connector_ua_is_dynamic(self):
+        t = (_REPO / "mindforge" / "modules" / "connectors.py").read_text(
+            encoding="utf-8")
+        # 修复后的形态：f-string 引用 __version__
+        self.assertIn('f"MindForge-Connector/{__version__}"', t,
+                      "connectors UA 应动态引用 __version__")
+        # 病灶形态必须消失：任何带版本号的硬编码 UA
+        bad = re.findall(r'User-Agent[^)]*?/[0-9]+\.[0-9]+\.[0-9]+', t)
+        self.assertEqual(bad, [], f"发现硬编码版本 UA: {bad}")
+        # import 必须存在（防 f-string 引用悬空）
+        self.assertIn("from mindforge.core.version import __version__", t)
+
+    def test_no_stale_version_in_runtime_ua(self):
+        """全包扫描：运行时 UA/标识字符串不得携带过时版本字面量。"""
+        pat = re.compile(r'MindForge[-A-Za-z]*/(?:\d+\.\d+\.\d+)')
+        for py in (_REPO / "mindforge").rglob("*.py"):
+            hits = pat.findall(py.read_text(encoding="utf-8"))
+            # 允许出现的位置：注释里的历史说明（v6.4.5 fix 注释提及旧值）
+            for line_no, line in enumerate(
+                    py.read_text(encoding="utf-8").splitlines(), 1):
+                if pat.search(line) and "v6.4.5 fix" not in line:
+                    # schema 标识（mindforge-knowledge-graph/1.0）为协议
+                    # 格式版本，非产品版本，豁免。
+                    if "knowledge-graph" in line:
+                        continue
+                    self.fail(
+                        f"{py.name}:{line_no} 疑似硬编码版本 UA: {line.strip()}")
+
+
+class TestWebsiteModuleCountTruth(unittest.TestCase):
+    """官网「核心模块」数 = mindforge/modules/ 实测文件数（防再过时）。"""
+
+    def _modules_count(self) -> int:
+        return len([p for p in (_REPO / "mindforge" / "modules").glob("*.py")
+                    if not p.name.startswith("_")])
+
+    def test_website_module_count_matches_reality(self):
+        want = str(self._modules_count())
+        index = (_REPO / "website" / "index.html").read_text(encoding="utf-8")
+        spots = {
+            "正文": re.findall(r'(\d+) 个核心模块', index),
+            "统计卡": re.findall(
+                r'class="about-stat"><b>(\d+)</b><span>核心模块<', index),
+        }
+        for k, v in spots.items():
+            self.assertEqual(len(v), 1, f"官网「{k}」核心模块数不唯一: {v}")
+            self.assertEqual(v[0], want,
+                f"官网「{k}」={v[0]}，实测 modules/={want}")
+
+    def test_website_mcp_tool_count_matches_reality(self):
+        """MCP 工具数守卫（87 实测口径；import server 拿 TOOL_SCHEMAS）。"""
+        try:
+            from mindforge.mcp.server import TOOL_SCHEMAS
+        except Exception as exc:  # pragma: no cover
+            self.skipTest(f"server 模块不可导入: {exc}")
+        want = str(len(TOOL_SCHEMAS))
+        index = (_REPO / "website" / "index.html").read_text(encoding="utf-8")
+        hits = re.findall(r'(\d+) 个? ?MCP 工具|(\d+) MCP tools', index)
+        flat = [x for pair in hits for x in pair if x]
+        self.assertTrue(flat, "官网未声明 MCP 工具数")
+        for v in flat:
+            self.assertEqual(v, want, f"官网 MCP 工具数 {v} ≠ 实测 {want}")
+
+
+class TestVersionBump(unittest.TestCase):
+    """版本钉值：忘记 bump 时在此显形。"""
+
+    def test_version_is_current(self):
+        self.assertEqual(__version__, "6.4.6")
+
+
+if __name__ == "__main__":
+    unittest.main()