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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindforge-memory
-Version: 6.4.6
+Version: 6.4.9
 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.5: no team, no funding, 1,243 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.9: no team, no funding, 1,257 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.6-green.svg)](https://github.com/opok-ops/MindForge/releases)
+[![Version](https://img.shields.io/badge/version-6.4.9-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)
@@ -95,22 +95,27 @@ MindForge stats
 ```
 
 
-## Scale & Quality Benchmarks (v6.4.6, measured)
+## Scale & Quality Benchmarks (v6.4.9, 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 |
+| Scale | add throughput | search p50 (rare token) | search p50 (realistic mixed) | search p50 (pathological all-common) | db size |
+|---|---|---|---|---|---|
+| 200 entries (baseline) | — | 1.8 ms | — | — | <1 MB |
+| 10,000 | 1,080/s | ~9.5 ms | ~16 ms | — | 10 MB |
+| 100,000 (~10M chars) | ~546/s | 6.8 ms | 3.0 ms | 0.4 ms | 98 MB |
 
+- **Ten-million-character library, millisecond-class across all query types (v6.4.9)**: pathological 218→**0.4ms** (−99.8%), mixed 143→**3.0ms** (−98%), rare 6.8ms, combined 17.8ms (100k full-pipeline, clean environment). The last bottleneck — FTS5 high-frequency-phrase bm25 scoring — is now pruned query-side via trigram-df pre-check (df upper bound = min trigram df, pruned at 5% corpus size, symmetric to the TF-IDF max_df design; df served from an in-process cache — fts5vocab is a streaming virtual table, per-term probes scan it fully).
+- **Index-blindness fix (v6.4.8)**: TF-IDF vocabulary was locked to the first 5 documents since v6.4.6 — incremental adds indexed as empty vectors (TF-IDF effectively half-dead; previous numbers carried by FTS5/fuzzy). Fixed with incremental vocabulary growth; all pipeline numbers above are now *true full-pipeline* measurements.
 - 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.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.1.3 – v6.4.9 shipped in ten days (2026-11-01 → 11-11; four releases in the last two days), guarded by **1,258 tests** (1,257 passing, 1 environment-skipped).
+
+- **v6.4.9 — ten-million-char library at millisecond latency: FTS5 high-frequency-phrase scoring pruned** (2026-11-11). The last honest bottleneck from v6.4.8's ledger. Root cause (30k per-path timing): under the trigram tokenizer, corpus-wide phrases (template data's "陈述性记忆") match every row — bm25 full-match scoring cost 50.5ms/query, the dominant remainder of 100k mixed latency. Fix, query-side df pre-pruning symmetric to TF-IDF max_df: a phrase's df upper bound = min df of its trigrams (phrase matches ⊆ every trigram's row set); prune at 5% of corpus size; keep the lowest-ub phrase if all pruned. df is served from an in-process cache keyed by `max(rowid)` (add/update invalidate; hard-delete leaves df slightly stale = prunes more conservatively) — **two real pitfalls found en route: fts5vocab is a *streaming virtual table* — per-term probes AND `IN` batches trigger full scans (combined regressed 17→45ms before the cache)**. Plus: FTS5 path skipped on pathological fallback (no discriminating signal). Clean-environment 100k re-bench: pathological 122→**0.4ms** (−99.7%), mixed 134.9→**3.0ms** (−98%), all query types millisecond-class at ~10M chars. AI-flavored comment cleanup (essay-style docstrings → engineer-speak, info preserved). 5 new guards.
+
+- **v6.4.8 — pathological query path & index-blindness fix: O(N) fallback eliminated, TF-IDF actually indexing** (2026-11-11). Two deeper findings beyond the v6.4.6 stress test: (1) the all-common-word fallback traversed *all* inverted chains at full length (O(N×dims), 209ms p50 at 100k), and the 0.5×N max_df threshold still let half-corpus chains into the active set; (2) **the TF-IDF vocabulary had been locked to the first 5 documents** — every incremental add after that indexed as an empty vector (the TF-IDF path was effectively half-dead since v6.4.6; published numbers were carried by FTS5/fuzzy). Fix, six cuts: max_df tightened 0.5×N→**0.05×N**; fallback semantics → **shortest-chain-first** (≤3 dims, per-chain cap 5,000, islice); fuzzy candidate budget (SQL cap 2,000 with exact-substring-first ordering); fuzzy gating (runs only on zero TF-IDF hits — the true typo-correction scenario; encrypted mode unaffected); `incremental_fit()` vocabulary growth for adds after fit (old vectors not recomputed — new tokens contribute zero on old docs mathematically); empty-query fallback-signal reset. 30k repro: pathological steady-state 3825→**4.0ms** (−99.9%), mixed pipeline 1607→1.2ms, fuzzy single-path −93%. 100k re-bench: pathological −44%, all numbers now true full-pipeline. Remaining bottleneck honestly documented: FTS5 high-frequency-phrase scoring (v6.5). New observable `_last_traversed` + deterministic budget contracts. 9 new guards.
 
 - **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`.
@@ -183,7 +188,7 @@ v6.1.3 – v6.4.5 shipped in ten days (2026-11-01 → 11-10; two same-day releas
 
 ```
 ┌──────────────────────────────────────────────────────┐
-│           MindForge v6.4.6            │
+│           MindForge v6.4.9            │
 │  Cognitive Layer  Personality · KnowledgeGraph       │
 │                   MemoryEvolution · FederatedMemory  │
 ├──────────────────────────────────────────────────────┤

{mindforge_memory-6.4.6 → mindforge_memory-6.4.9}/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.5: no team, no funding, 1,243 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.9: no team, no funding, 1,257 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.6-green.svg)](https://github.com/opok-ops/MindForge/releases)
+[![Version](https://img.shields.io/badge/version-6.4.9-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)
@@ -65,22 +65,27 @@ MindForge stats
 ```
 
 
-## Scale & Quality Benchmarks (v6.4.6, measured)
+## Scale & Quality Benchmarks (v6.4.9, 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 |
+| Scale | add throughput | search p50 (rare token) | search p50 (realistic mixed) | search p50 (pathological all-common) | db size |
+|---|---|---|---|---|---|
+| 200 entries (baseline) | — | 1.8 ms | — | — | <1 MB |
+| 10,000 | 1,080/s | ~9.5 ms | ~16 ms | — | 10 MB |
+| 100,000 (~10M chars) | ~546/s | 6.8 ms | 3.0 ms | 0.4 ms | 98 MB |
 
+- **Ten-million-character library, millisecond-class across all query types (v6.4.9)**: pathological 218→**0.4ms** (−99.8%), mixed 143→**3.0ms** (−98%), rare 6.8ms, combined 17.8ms (100k full-pipeline, clean environment). The last bottleneck — FTS5 high-frequency-phrase bm25 scoring — is now pruned query-side via trigram-df pre-check (df upper bound = min trigram df, pruned at 5% corpus size, symmetric to the TF-IDF max_df design; df served from an in-process cache — fts5vocab is a streaming virtual table, per-term probes scan it fully).
+- **Index-blindness fix (v6.4.8)**: TF-IDF vocabulary was locked to the first 5 documents since v6.4.6 — incremental adds indexed as empty vectors (TF-IDF effectively half-dead; previous numbers carried by FTS5/fuzzy). Fixed with incremental vocabulary growth; all pipeline numbers above are now *true full-pipeline* measurements.
 - 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.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.1.3 – v6.4.9 shipped in ten days (2026-11-01 → 11-11; four releases in the last two days), guarded by **1,258 tests** (1,257 passing, 1 environment-skipped).
+
+- **v6.4.9 — ten-million-char library at millisecond latency: FTS5 high-frequency-phrase scoring pruned** (2026-11-11). The last honest bottleneck from v6.4.8's ledger. Root cause (30k per-path timing): under the trigram tokenizer, corpus-wide phrases (template data's "陈述性记忆") match every row — bm25 full-match scoring cost 50.5ms/query, the dominant remainder of 100k mixed latency. Fix, query-side df pre-pruning symmetric to TF-IDF max_df: a phrase's df upper bound = min df of its trigrams (phrase matches ⊆ every trigram's row set); prune at 5% of corpus size; keep the lowest-ub phrase if all pruned. df is served from an in-process cache keyed by `max(rowid)` (add/update invalidate; hard-delete leaves df slightly stale = prunes more conservatively) — **two real pitfalls found en route: fts5vocab is a *streaming virtual table* — per-term probes AND `IN` batches trigger full scans (combined regressed 17→45ms before the cache)**. Plus: FTS5 path skipped on pathological fallback (no discriminating signal). Clean-environment 100k re-bench: pathological 122→**0.4ms** (−99.7%), mixed 134.9→**3.0ms** (−98%), all query types millisecond-class at ~10M chars. AI-flavored comment cleanup (essay-style docstrings → engineer-speak, info preserved). 5 new guards.
+
+- **v6.4.8 — pathological query path & index-blindness fix: O(N) fallback eliminated, TF-IDF actually indexing** (2026-11-11). Two deeper findings beyond the v6.4.6 stress test: (1) the all-common-word fallback traversed *all* inverted chains at full length (O(N×dims), 209ms p50 at 100k), and the 0.5×N max_df threshold still let half-corpus chains into the active set; (2) **the TF-IDF vocabulary had been locked to the first 5 documents** — every incremental add after that indexed as an empty vector (the TF-IDF path was effectively half-dead since v6.4.6; published numbers were carried by FTS5/fuzzy). Fix, six cuts: max_df tightened 0.5×N→**0.05×N**; fallback semantics → **shortest-chain-first** (≤3 dims, per-chain cap 5,000, islice); fuzzy candidate budget (SQL cap 2,000 with exact-substring-first ordering); fuzzy gating (runs only on zero TF-IDF hits — the true typo-correction scenario; encrypted mode unaffected); `incremental_fit()` vocabulary growth for adds after fit (old vectors not recomputed — new tokens contribute zero on old docs mathematically); empty-query fallback-signal reset. 30k repro: pathological steady-state 3825→**4.0ms** (−99.9%), mixed pipeline 1607→1.2ms, fuzzy single-path −93%. 100k re-bench: pathological −44%, all numbers now true full-pipeline. Remaining bottleneck honestly documented: FTS5 high-frequency-phrase scoring (v6.5). New observable `_last_traversed` + deterministic budget contracts. 9 new guards.
 
 - **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`.
@@ -153,7 +158,7 @@ v6.1.3 – v6.4.5 shipped in ten days (2026-11-01 → 11-10; two same-day releas
 
 ```
 ┌──────────────────────────────────────────────────────┐
-│           MindForge v6.4.6            │
+│           MindForge v6.4.9            │
 │  Cognitive Layer  Personality · KnowledgeGraph       │
 │                   MemoryEvolution · FederatedMemory  │
 ├──────────────────────────────────────────────────────┤

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

@@ -9,6 +9,7 @@ import os
 import re
 import sqlite3
 from collections import Counter, defaultdict
+from itertools import islice
 from typing import List, Dict, Tuple, Optional
 from dataclasses import dataclass
 
@@ -28,6 +29,7 @@ class TFIDFVectorizer:
     def __init__(self):
         self.vocab: Dict[str, int] = {}
         self.idf: Dict[str, float] = {}
+        self._df: Dict[str, int] = {}  # v6.4.8: 增量 fit 的精确 df 延续
         self.doc_count: int = 0
 
     def _tokenize(self, text: str) -> List[str]:
@@ -59,6 +61,33 @@ class TFIDFVectorizer:
 
         for word, idx in self.vocab.items():
             self.idf[word] = math.log((self.doc_count + 1) / (df[word] + 1)) + 1
+        # v6.4.8: df 表留存，供 incremental_fit 延续精确计数
+        self._df = dict(df)
+
+    def incremental_fit(self, text: str) -> None:
+        """v6.4.8 新增：单文档增量词表扩展。
+
+        修复「fit 后新增文档失索引」：新 token 按当前 doc_count+1 估
+        IDF 补进词表；已知 token 的 df 计数 +1（IDF 漂移不回算旧向量，
+        见 index_memory 注释）。维度号从当前词表长度起追加，与既有
+        向量维度兼容（旧文档在新词上恒为零分量）。
+        """
+        if not self._df:
+            # 未 fit 过（不应发生——调用方保证 fitted），防御性直通
+            return
+        self.doc_count += 1
+        next_idx = len(self.vocab)
+        for token in set(self._tokenize(text)):
+            if token in self.vocab:
+                self._df[token] = self._df.get(token, 0) + 1
+                self.idf[token] = math.log(
+                    (self.doc_count + 1) / (self._df[token] + 1)) + 1
+            else:
+                self._df[token] = 1
+                self.vocab[token] = next_idx
+                next_idx += 1
+                self.idf[token] = math.log(
+                    (self.doc_count + 1) / 2) + 1
 
     def transform(self, text: str) -> Dict[int, float]:
         tokens = self._tokenize(text)
@@ -108,6 +137,10 @@ class VectorIndex:
         self.metadata: Dict[str, Dict] = {}
         self._norms: Dict[str, float] = {}  # 预计算 L2 范数缓存
         self._postings: Dict[int, Dict[str, float]] = {}  # 倒排链
+        # v6.4.8: 上次 search 实际遍历的倒排链条目数（性能契约可观测）
+        self._last_traversed = 0
+        # v6.4.8: 上次 search 是否走了病态回退（全库词查询信号）
+        self.last_fallback = False
 
     @staticmethod
     def _as_sparse(vector) -> Dict[int, float]:
@@ -150,31 +183,70 @@ class VectorIndex:
         q = self._as_sparse(query_vector)
         query_norm = math.sqrt(sum(v * v for v in q.values()))
         if query_norm == 0:
+            # v6.4.8: 空查询（无 token/全 vocab miss）≠ 全库词回退。
+            # 显式复位 last_fallback，防止继承上一查询的 True 导致
+            # query.py 误跳过 fuzzy 拼写兜底（空查询正是 fuzzy 的
+            # 设计场景：用户词打错 → 全 miss → fuzzy 纠错召回）。
+            self.last_fallback = False
+            self._last_traversed = 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 相对阈值 + max_df 停用词。
+        # v6.4.8 perf: max_df 从 0.5×N 收紧到 0.05×N。0.5 时半库词链
+        # （数十万级遍历）仍进 active，100k 实测 mixed_realistic p50
+        # 134ms。常见词的点积贡献近似常数（30k profile 实证 eps 剪不掉
+        # 全库词，v6.4.6 注释已论证 top-K 排序不变），链长超库容 5% 的
+        # 维一律剪——100k 库下 active 链长上界 5k，遍历毫秒级。
         _EPS_REL = 0.02
-        _half = 0.5 * len(self.vectors)
+        _max_df_len = 0.05 * 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]
+                  and len(self._postings.get(idx, ())) <= _max_df_len]
+        self._last_traversed = 0
+        # v6.4.8: 全库词回退信号（供 query.py 跳过 fuzzy/FTS5 兜底）
+        self.last_fallback = False
         if not active:
-            # 全部维度被剪（极端退化查询）：退回原语义，保证不空召回
-            active = list(q.items())
+            self.last_fallback = True
+            # v6.4.8: 回退不再遍历全部倒排链（旧 O(N×dims) 是 100k
+            # 全库词查询 209ms 的根因）。全库词点积贡献是常数，top-K
+            # 只由相对区分度决定：取最短 _FALLBACK_DIMS 维（区分度最高
+            # 的信号），单链截断 _TRAVERSE_CAP 项（平分数下截断不改
+            # top-K 语义）。
+            _FALLBACK_DIMS = 3
+            _TRAVERSE_CAP = 5000
+            ranked = sorted(
+                q.items(),
+                key=lambda kv: len(self._postings.get(kv[0], ())))
+            active = ranked[:_FALLBACK_DIMS]
+            # islice 免建截断副本（dict(list(x)[:cap]) 的 15k 次 hash
+            # 插入在实测里占 ~3ms，30k 病态复现 14→11ms）
+            dots: Dict[str, float] = {}
+            for idx, qval in active:
+                chain = self._postings.get(idx, {})
+                pairs = (chain.items() if len(chain) <= _TRAVERSE_CAP
+                         else islice(chain.items(), _TRAVERSE_CAP))
+                for doc_id, dval in pairs:
+                    dots[doc_id] = dots.get(doc_id, 0.0) + qval * dval
+                    self._last_traversed += 1
+            return self._topk_from_dots(dots, query_norm, top_k)
 
         # 倒排链累加点积：只访问与查询共享非零维度的候选文档
+        # （active 链长上界 _max_df_len，遍历量与库容解耦）
         dots: Dict[str, float] = {}
         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
+                self._last_traversed += 1
 
         # v6.4.6 perf: heapq.nlargest 替代全量 sort——候选集大时
         # O(n·log k) 优于 O(n·log n)，且免建全量列表排序的中间开销。
+        return self._topk_from_dots(dots, query_norm, top_k)
+
+    def _topk_from_dots(self, dots: Dict[str, float], query_norm: float,
+                        top_k: int) -> List[Tuple[str, float]]:
+        """点积累积结果归一化 + top-K 选取（v6.4.8 抽出，回退/正常路径共用）"""
         return heapq.nlargest(
             top_k,
             ((doc_id, dot / (query_norm * self._norms[doc_id]))
@@ -212,6 +284,11 @@ class IndexEngine:
         self.db_path = db_path
         self.vectorizer = TFIDFVectorizer()
         self.vector_index = VectorIndex()
+        # v6.4.8: 病态回退信号门面透传（见 search()）
+        self.last_fallback = False
+        # v6.4.9: FTS5 trigram df 进程内缓存（见 _prune_fts_query）
+        self._fts_vocab_cache: Optional[Dict[str, int]] = None
+        self._fts_vocab_rowid: int = -1
         self._fitted = False
         self._hydrated = False
         self._doc_texts: Dict[str, str] = {}
@@ -269,16 +346,20 @@ class IndexEngine:
         """索引记忆"""
         self._doc_texts[doc_id] = text
 
+        # v5.6.5 P1 #5: 渐进 fit 触发点（LRU 守卫契约：add 即索引）。
+        # v6.4.8 fix: fit 后的增量 add 先 incremental_fit 扩词表再
+        # transform——旧逻辑词表锁死在前 5 条文档，此后增量 add 的
+        # transform 全 vocab miss（空向量入索引，TF-IDF 路半瘫痪）。
         if not self._fitted and len(self._doc_texts) >= 5:
             self._fit_vectorizer()
+        elif self._fitted:
+            self.vectorizer.incremental_fit(text)
 
         if self._fitted:
-            # v5.6.3 性能修复：直接存稀疏向量（{dim: weight}），不再展开为
-            # 词表长度的稠密 list
             vector_dict = self.vectorizer.transform(text)
             self.vector_index.add(doc_id, vector_dict, metadata)
 
-        # v5.6.5 P1 #5：写入后做 LRU 淘汰（覆盖写不增加条目数，故在 add 之后）
+        # v5.6.5 P1 #5: 写入后 LRU 淘汰
         self._evict_if_needed()
 
     def remove_memory(self, doc_id: str):
@@ -292,11 +373,17 @@ class IndexEngine:
             self._fit_vectorizer()
 
         if not self._fitted:
+            # v6.4.8: 降级路径同样透传病态回退信号（保持门面契约一致）
+            self.last_fallback = False
             return self._keyword_search(query, top_k)
 
         # v5.6.3 性能修复：查询向量同样保持稀疏，走倒排链检索
         query_vec_dict = self.vectorizer.transform(query)
-        return self.vector_index.search(query_vec_dict, top_k)
+        results = self.vector_index.search(query_vec_dict, top_k)
+        # v6.4.8: 把 VectorIndex 的病态回退信号透传到门面层
+        # （query.py 据此跳过 fuzzy 兜底路）
+        self.last_fallback = self.vector_index.last_fallback
+        return results
 
     def _keyword_search(self, query: str, top_k: int) -> List[Tuple[str, float]]:
         """关键词搜索（降级方案）"""
@@ -352,9 +439,16 @@ class IndexEngine:
 
     def fts_search(self, conn: sqlite3.Connection, query: str,
                    top_k: int = 10) -> List[Tuple[str, float]]:
-        """FTS5 全文搜索（v5.4.7 修复：特殊字符转义）"""
+        """FTS5 全文搜索（v5.4.7 修复：特殊字符转义）
+
+        v6.4.9: 多词查询先经 _prune_fts_query 剔除高频短语——
+        trigram 索引下全库短语的 bm25 评分是 100k 延迟的大头。
+        """
         try:
             escaped = self._escape_fts5_query(query)
+            if not escaped:
+                return []
+            escaped = self._prune_fts_query(conn, query, escaped)
             if not escaped:
                 return []
             rows = conn.execute("""
@@ -380,3 +474,62 @@ class IndexEngine:
             return results
         except sqlite3.OperationalError:
             return []
+
+    # v6.4.9: 高频短语剪枝比例（与 TF-IDF max_df 0.05 对齐）
+    _FTS_MAX_DF_RATIO = 0.05
+
+    def _prune_fts_query(self, conn: sqlite3.Connection, query: str,
+                         escaped: str) -> str:
+        """剔除 MATCH 里必然无区分度的高频短语。
+
+        短语 df 上界 = min(该词全部 trigram 的 df)（短语匹配行 ⊆
+        每个 trigram 行集的交集）。上界超库容 5% 的词剔除；全被剔除
+        时留上界最小的那个，防空 MATCH。
+        df 来自 fts5vocab 的进程内缓存（首查全表读一次，此后 O(1)
+        点查；以 memories.max_rowid 为失效标记，覆盖 add/update；
+        硬删导致的 df 缓存偏大只会让剪枝偏保守，5% 阈值级近似）。
+        """
+        tokens = [t for t in query.split() if t]
+        if len(tokens) <= 1:
+            return escaped
+        try:
+            row = conn.execute(
+                "SELECT max(rowid) FROM memories").fetchone()
+            total = (row[0] or 0) if row else 0
+            if total < 200:
+                return escaped  # 小库 df 语义不稳
+            if (self._fts_vocab_cache is None
+                    or total != self._fts_vocab_rowid):
+                # v6.4.9: vocab 是流式虚拟表，逐 term 点查/IN 批查
+                # 都触发全表扫（combined 100k 45ms 回退的根因）——
+                # 全表读一次进 dict，之后纯内存点查。
+                conn.execute(
+                    "CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts_v "
+                    "USING fts5vocab('memory_fts', 'row')")
+                self._fts_vocab_cache = dict(
+                    conn.execute("SELECT term, doc FROM memory_fts_v"))
+                self._fts_vocab_rowid = total
+            df_map = self._fts_vocab_cache
+            budget = self._FTS_MAX_DF_RATIO * total
+            kept = []
+            best, best_ub = None, None
+            for tok in tokens:
+                if len(tok) < 3:
+                    ub = 0  # trigram 查不了短词，保留
+                else:
+                    ub = min(df_map.get(tok[i:i + 3], 0)
+                             for i in range(len(tok) - 2))
+                if ub <= budget:
+                    kept.append(tok)
+                if best_ub is None or ub < best_ub:
+                    best, best_ub = tok, ub
+            if not kept:
+                kept = [best] if best else []
+                return " OR ".join(
+                    '"' + t.replace('"', '""') + '"' for t in kept)
+            if len(kept) == len(tokens):
+                return escaped
+            return " OR ".join(
+                '"' + t.replace('"', '""') + '"' for t in kept)
+        except sqlite3.Error:
+            return escaped

{mindforge_memory-6.4.6 → mindforge_memory-6.4.9}/mindforge/core/query.py

@@ -257,11 +257,19 @@ class QueryEngine:
                     _bd(doc_id)["winner"] = "tfidf"
                     _bd(doc_id)["final"] = s
 
-        # 路 2：Fuzzy（TF-IDF 召回不足时补充；v5.7.1：加密模式下总是跑，
-        # 供加密兜底复用结果，避免二次全表扫描）
-        positive = sum(1 for _, s in tfidf_results if s >= min_relevance)
+        # 路 2：Fuzzy（拼写纠错兜底；v5.7.1：加密模式下总是跑供加密
+        # 兜底复用，避免二次全表扫描）
+        # v6.4.8: 触发收紧为「TF-IDF 零有效命中」。fuzzy 的价值在
+        # 「查询词全不在库」（打错字场景），此时 TF-IDF 必空。有命中
+        # （含低分）时 fuzzy 只补凑数条目还白扫候选集（30k 实测
+        # 140ms/查询）。全库词回退（tfidf_fallback）同理跳过。
+        # 注意按非零分判定：空查询走零分 top-K 兼容分支，
+        # tfidf_results 恒非空，不看分会死锁拼写兜底。
+        tfidf_fallback = getattr(self.index, "last_fallback", False)
+        tfidf_effective = any(s > 0.0 for _, s in tfidf_results)
         fuzzy_hits = []
-        if self.storage.encrypted or positive < max_results:
+        if (self.storage.encrypted
+                or (not tfidf_effective and not tfidf_fallback)):
             fuzzy_hits = self.storage.fuzzy_search(
                 query, limit=max_results * 2, threshold=0.1)
             for item in fuzzy_hits:
@@ -276,23 +284,29 @@ class QueryEngine:
                         _bd(entry.id)["final"] = s
 
         # 路 3：FTS5 全文检索
+        # v6.4.9: 全库词回退时跳过（FTS5 对高频短语的 bm25 全匹配行
+        # 评分是病态查询的主要剩余成本，且无区分度信号）。正常查询
+        # 走 fts_search 的 df 剪枝。
         fts5_used = False
-        # v5.6.2 安全修复：初始化默认值，防止异常路径下 UnboundLocalError
+        # v5.6.2: 防异常路径下 UnboundLocalError
         strategy_used = "tfidf+fuzzy"
         try:
-            conn = self.storage._get_conn()
-            fts_results = self.index.fts_search(conn, query, top_k=max_results * 3)
-            for doc_id, s in fts_results:
-                if explain:
-                    _bd(doc_id)["fts5"] = max(s, _bd(doc_id)["fts5"])
-                if s >= score_map.get(doc_id, 0.0):
-                    score_map[doc_id] = s
+            if not tfidf_fallback:
+                conn = self.storage._get_conn()
+                fts_results = self.index.fts_search(conn, query, top_k=max_results * 3)
+                for doc_id, s in fts_results:
                     if explain:
-                        _bd(doc_id)["winner"] = "fts5"
-                        _bd(doc_id)["final"] = s
-            if fts_results:
-                fts5_used = True
-                strategy_used = "tfidf+fuzzy+fts5"
+                        _bd(doc_id)["fts5"] = max(s, _bd(doc_id)["fts5"])
+                    if s >= score_map.get(doc_id, 0.0):
+                        score_map[doc_id] = s
+                        if explain:
+                            _bd(doc_id)["winner"] = "fts5"
+                            _bd(doc_id)["final"] = s
+                if fts_results:
+                    fts5_used = True
+                    strategy_used = "tfidf+fuzzy+fts5"
+                else:
+                    strategy_used = "tfidf+fuzzy"
             else:
                 strategy_used = "tfidf+fuzzy"
         except Exception:

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

@@ -9127,6 +9127,16 @@ class StorageEngine:
                     params_or.append(f"%{_ch}%")
         cand_query = base_query + " AND (" + " OR ".join(conds) + ")"
 
+        # v6.4.8: 候选集预算。短条目库 + 16 字级中文查询会让候选
+        # ≈ 全库（30k 实测 1642ms）；超预算只发生在无区分度查询，
+        # 平分数下截断不改 top-K。排序：精确子串命中（LIKE，最强
+        # fuzzy 信号）排最前，短文本兜底路按 rowid 截断。
+        _FUZZY_CAND_CAP = 2000
+        cand_query += (
+            " ORDER BY (CASE WHEN content LIKE ? THEN 0 ELSE 1 END), rowid"
+            f" LIMIT {_FUZZY_CAND_CAP}")
+        params_or.append(f"%{query_lower}%")
+
         def _entry_iter():
             for _r in conn.execute(cand_query, params + params_or):
                 yield self._row_to_entry(_r)

{mindforge_memory-6.4.6 → mindforge_memory-6.4.9}/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.6"
+__version__: str = "6.4.9"
 
 #: 结构化版本元组，便于比较（如 `VERSION_INFO >= (6, 1, 0)`）
-VERSION_INFO: Tuple[int, int, int] = (6, 4, 6)
+VERSION_INFO: Tuple[int, int, int] = (6, 4, 9)
 
 #: 下一个大版本的目标版本号（供 v6 端口预留引用）
 NEXT_MAJOR_TARGET: str = "7.0.0"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindforge-memory
-Version: 6.4.6
+Version: 6.4.9
 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.5: no team, no funding, 1,243 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.9: no team, no funding, 1,257 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.6-green.svg)](https://github.com/opok-ops/MindForge/releases)
+[![Version](https://img.shields.io/badge/version-6.4.9-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)
@@ -95,22 +95,27 @@ MindForge stats
 ```
 
 
-## Scale & Quality Benchmarks (v6.4.6, measured)
+## Scale & Quality Benchmarks (v6.4.9, 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 |
+| Scale | add throughput | search p50 (rare token) | search p50 (realistic mixed) | search p50 (pathological all-common) | db size |
+|---|---|---|---|---|---|
+| 200 entries (baseline) | — | 1.8 ms | — | — | <1 MB |
+| 10,000 | 1,080/s | ~9.5 ms | ~16 ms | — | 10 MB |
+| 100,000 (~10M chars) | ~546/s | 6.8 ms | 3.0 ms | 0.4 ms | 98 MB |
 
+- **Ten-million-character library, millisecond-class across all query types (v6.4.9)**: pathological 218→**0.4ms** (−99.8%), mixed 143→**3.0ms** (−98%), rare 6.8ms, combined 17.8ms (100k full-pipeline, clean environment). The last bottleneck — FTS5 high-frequency-phrase bm25 scoring — is now pruned query-side via trigram-df pre-check (df upper bound = min trigram df, pruned at 5% corpus size, symmetric to the TF-IDF max_df design; df served from an in-process cache — fts5vocab is a streaming virtual table, per-term probes scan it fully).
+- **Index-blindness fix (v6.4.8)**: TF-IDF vocabulary was locked to the first 5 documents since v6.4.6 — incremental adds indexed as empty vectors (TF-IDF effectively half-dead; previous numbers carried by FTS5/fuzzy). Fixed with incremental vocabulary growth; all pipeline numbers above are now *true full-pipeline* measurements.
 - 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.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.1.3 – v6.4.9 shipped in ten days (2026-11-01 → 11-11; four releases in the last two days), guarded by **1,258 tests** (1,257 passing, 1 environment-skipped).
+
+- **v6.4.9 — ten-million-char library at millisecond latency: FTS5 high-frequency-phrase scoring pruned** (2026-11-11). The last honest bottleneck from v6.4.8's ledger. Root cause (30k per-path timing): under the trigram tokenizer, corpus-wide phrases (template data's "陈述性记忆") match every row — bm25 full-match scoring cost 50.5ms/query, the dominant remainder of 100k mixed latency. Fix, query-side df pre-pruning symmetric to TF-IDF max_df: a phrase's df upper bound = min df of its trigrams (phrase matches ⊆ every trigram's row set); prune at 5% of corpus size; keep the lowest-ub phrase if all pruned. df is served from an in-process cache keyed by `max(rowid)` (add/update invalidate; hard-delete leaves df slightly stale = prunes more conservatively) — **two real pitfalls found en route: fts5vocab is a *streaming virtual table* — per-term probes AND `IN` batches trigger full scans (combined regressed 17→45ms before the cache)**. Plus: FTS5 path skipped on pathological fallback (no discriminating signal). Clean-environment 100k re-bench: pathological 122→**0.4ms** (−99.7%), mixed 134.9→**3.0ms** (−98%), all query types millisecond-class at ~10M chars. AI-flavored comment cleanup (essay-style docstrings → engineer-speak, info preserved). 5 new guards.
+
+- **v6.4.8 — pathological query path & index-blindness fix: O(N) fallback eliminated, TF-IDF actually indexing** (2026-11-11). Two deeper findings beyond the v6.4.6 stress test: (1) the all-common-word fallback traversed *all* inverted chains at full length (O(N×dims), 209ms p50 at 100k), and the 0.5×N max_df threshold still let half-corpus chains into the active set; (2) **the TF-IDF vocabulary had been locked to the first 5 documents** — every incremental add after that indexed as an empty vector (the TF-IDF path was effectively half-dead since v6.4.6; published numbers were carried by FTS5/fuzzy). Fix, six cuts: max_df tightened 0.5×N→**0.05×N**; fallback semantics → **shortest-chain-first** (≤3 dims, per-chain cap 5,000, islice); fuzzy candidate budget (SQL cap 2,000 with exact-substring-first ordering); fuzzy gating (runs only on zero TF-IDF hits — the true typo-correction scenario; encrypted mode unaffected); `incremental_fit()` vocabulary growth for adds after fit (old vectors not recomputed — new tokens contribute zero on old docs mathematically); empty-query fallback-signal reset. 30k repro: pathological steady-state 3825→**4.0ms** (−99.9%), mixed pipeline 1607→1.2ms, fuzzy single-path −93%. 100k re-bench: pathological −44%, all numbers now true full-pipeline. Remaining bottleneck honestly documented: FTS5 high-frequency-phrase scoring (v6.5). New observable `_last_traversed` + deterministic budget contracts. 9 new guards.
 
 - **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`.
@@ -183,7 +188,7 @@ v6.1.3 – v6.4.5 shipped in ten days (2026-11-01 → 11-10; two same-day releas
 
 ```
 ┌──────────────────────────────────────────────────────┐
-│           MindForge v6.4.6            │
+│           MindForge v6.4.9            │
 │  Cognitive Layer  Personality · KnowledgeGraph       │
 │                   MemoryEvolution · FederatedMemory  │
 ├──────────────────────────────────────────────────────┤

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

@@ -135,4 +135,6 @@ tests/test_v636_fixes.py
 tests/test_v643_fixes.py
 tests/test_v645_fixes.py
 tests/test_v646_fixes.py
+tests/test_v648_fixes.py
+tests/test_v649_fixes.py
 tests/test_v6_ports.py

{mindforge_memory-6.4.6 → mindforge_memory-6.4.9}/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.6"
+_EXPECTED_VERSION = "6.4.9"
 
 # 本轮修复涉及的、必须与 mindforge/core/version.py 保持一致的源码文件
 _VERSION_TRUTH_FILES = (

{mindforge_memory-6.4.6 → mindforge_memory-6.4.9}/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.6")
-        self.assertEqual(core_version.VERSION_INFO, (6, 4, 6))
+        self.assertEqual(core_version.__version__, "6.4.9")
+        self.assertEqual(core_version.VERSION_INFO, (6, 4, 9))
 
     def test_pyproject_matches_core_version(self):
         # v5.8.13 起 pyproject 不再写死静态版本：