Python
feat(sdk): rerank switch, size-gated MMR, scene="all" search and list, productivity edit/delete
alvinfei47dafbb102c1
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 812e70a..0240c6a 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -4,6 +4,33 @@ Hy Memory and MemHub are versioned and released independently.## Unreleased+- SDK: `search(..., rerank=False)` skips every reranking stage for that one+ call (the local cross-encoder, the memory-graph rerank, and the BM25 rerank of+ working/coding facts), so results come back in retrieval-score order. The+ flag travels on the read request, so concurrent searches do not affect each+ other. The default (`True`) keeps current behavior; `/api/v1/search` accepts+ it too.+- SDK: MMR diversity selection now runs only when the requested `limit` is+ below 20 (`MMR_MAX_TOP_K`) and is skipped for larger limits, where its+ quadratic token-overlap pass is slow and gains little. Previously it ran for+ every limit. `MEMORY_HYBRID_V2_MMR_LAMBDA` still sets the weight.+- SDK: `search(scene="all")` searches chat, working and coding at the same time+ and merges them with Reciprocal Rank Fusion (k=60) over each scene's own+ ranking, so no scene is crowded out by the other scenes' score scales. Each+ result says which scene and kind it came from. A scene that fails or is turned+ off is reported in `errors` and does not fail the search. Source filters apply+ to all three.+- SDK: `list_memories(scene="all")` lists chat, working and coding memories+ together, newest update first, with `limit`/`offset` paging over the merged+ order and `total` summing all three. `scene="coding"` and `"working"` now+ honor `include_sources` / `exclude_sources`, and `total` counts only the+ filtered memories.+- SDK: `update()` and `delete()` now work on working/coding experiences and+ facts, not just chat memories. They take the same optional `kind` / `variant`+ as `get()`, and an ID found in more than one place raises+ `AmbiguousMemoryIdError` instead of guessing. Updating an experience replaces+ its solution and keeps its task, unless a new `task=` is also passed; updating+ a fact replaces its statement. Deleting removes the stored row and its vectors.- SDK: `list_memories(scene="chat" | "coding" | "working")` lists one kind ofmemory. `coding` and `working` list that scene's whole store, newest updatefirst (`workspace_id` still narrows it), and `total` is now the real countdiff --git a/hy_memory/client.py b/hy_memory/client.pyindex 2b09091..dd37ed3 100644--- a/hy_memory/client.py+++ b/hy_memory/client.py@@ -88,6 +88,47 @@ _WORKING_EXPERIENCE_MIN_SCORE_DELTA = 0.10# (默认 999),这是防病态长链的安全阀,不是返回条数控制。_CODING_GET_MANY_MAX_IDS = 500+# search(scene="all") 的 Reciprocal Rank Fusion 常数:item 在本路第 rank 名+# (从 1 起)贡献 1 / (_SCENE_RRF_K + rank)。60 是 RRF 原论文(Cormack 2009)的+# 惯用值:只看名次不看分数,chat 与 working/coding 的分数量纲不同也不会互相压制。+_SCENE_RRF_K = 60++# scene="all" 的三条路,也是同分时的先后顺序。+_SCENE_LANES = ("chat", "working", "coding")+++def _epoch_seconds(value: Any, *, naive_is_utc: bool = False) -> Optional[int]:+ """datetime / ISO 字符串 / epoch 数字 → 秒级 epoch;取不到返回 None。"""+ stamp = _epoch_float(value, naive_is_utc=naive_is_utc)+ return int(stamp) if stamp is not None else None+++def _epoch_float(value: Any, *, naive_is_utc: bool = False) -> Optional[float]:+ """同 _epoch_seconds,但保留亚秒精度(排序用,避免同一秒内的先后被抹平)。++ naive_is_utc:生产力库的时间戳用 utcnow() 写、不带时区,必须按 UTC 解读,+ 否则与 chat 侧(本地时间 naive,经 .timestamp() 已是正确 epoch)比较先后时+ 会差出一个时区偏移。+ """+ from datetime import timezone++ if value is None or value == "":+ return None+ if isinstance(value, bool):+ return None+ if isinstance(value, (int, float)):+ return float(value)+ if isinstance(value, str):+ try:+ value = datetime.fromisoformat(value.rstrip("Z"))+ except ValueError:+ return None+ if not isinstance(value, datetime):+ return None+ if value.tzinfo is None and naive_is_utc:+ value = value.replace(tzinfo=timezone.utc)+ return value.timestamp()+_WRITE_DIAGNOSTIC_KEYS = ("agent_status",@@ -1309,6 +1350,8 @@ class HyMemoryClient:variant: str = "working",include_sources: Optional[List[str]] = None,exclude_sources: Optional[List[str]] = None,+ rerank: bool = True,+ query_embedding: Optional[List[float]] = None,) -> Dict[str, Any]:"""Coding 召回路径(事实主导的双层召回):@@ -1345,6 +1388,9 @@ class HyMemoryClient:层。这是可接受的——事实是"这个 repo 里发生过什么",跨 workspace 拿它去带经验没有意义——但结果里看不出来,所以退化时打 warning。+ rerank=False 时事实层跳过 BM25 词面融合重排(不传 query_text 给+ store.search_facts),按稠密分排序。+失败时 fail-safe:返回 success=True + 两层都空(不抛错)。"""fact_min_score = (_WORKING_FACT_DEFAULT_MIN_SCORE@@ -1417,7 +1463,13 @@ class HyMemoryClient:try:_t_embed = time.perf_counter()- embedding, embed_meta = await self._embed_service.embed_with_meta(target_query)+ if query_embedding:+ # 调用方已算好(scene="all" 三路共用一次 embed)+ embedding, embed_meta = list(query_embedding), {}+ else:+ embedding, embed_meta = await self._embed_service.embed_with_meta(+ target_query+ )if _tracer is not None:await _tracer.log_coding_embed(query=target_query, dims=len(embedding or []),@@ -1437,7 +1489,7 @@ class HyMemoryClient:top=max(limit, 5),# 词面通道 + 把下面那道闸门下移到重排之前:先砍掉过不了闸的候选再重排,# 返回条数就恒等于纯稠密,词面只改选谁(理由见 store.search_facts)。- query_text=target_query,+ query_text=(target_query if rerank else None),min_score=fact_min_score,include_sources=include_sources,exclude_sources=exclude_sources,@@ -1783,6 +1835,7 @@ class HyMemoryClient:layers: Optional[List[Any]] = None,embed_override: Optional[Dict[str, Any]] = None,query_embedding: Optional[List[float]] = None,+ rerank: bool = True,) -> Dict[str, Any]:"""搜索记忆。@@ -1812,6 +1865,18 @@ class HyMemoryClient:- "working":强制走 coding(生产力)召回- "coding":同上,额外返回版本演进链块("chain_block" / "chain_used" 两个字段,见下方 Returns)+ - "all":chat / working / coding 三路并发召回后用 RRF+ 融合成一个列表(见下方 Returns)。chat 路用+ limit/min_score 等 chat 参数;working/coding 路用各自的+ working_fact_min_score / working_experience_min_score。+ 融合只看每路**自己的名次**:score = 1/(60 + rank),+ rank 从 1 起、k=60 为常数(RRF 惯用值),所以不同量纲+ 的分数不会互相压制;同分时按 chat → working → coding+ 排。融合后截断到 limit。某一路失败或未启用(coding 关、+ lite 模式)只是不贡献结果,记进 "errors",不会让整次+ search 失败;没写过的生产力场景直接跳过(不建空库)。+ include_sources / exclude_sources 对三路都生效;+ created_after / layers 只作用于 chat 路。(旧别名 "normal"/"productivity" 仍兼容)search_mode: 搜索执行模式:- "default"(默认):query="..." 是 light search,直接@@ -1825,7 +1890,13 @@ class HyMemoryClient:session_ids: Session ID 列表(空列表 = 搜索所有 session)include_sources: 调用来源白名单;空列表 = 不限。exclude_sources: 调用来源黑名单;与白名单冲突时黑名单优先。- limit: Normal 路的 topk 数量,默认 10+ limit: Normal 路的 topk 数量,默认 10。这也是 MMR 判定用的+ top-k:limit < 20(MMR_MAX_TOP_K,定义在+ pipelines/_retrieval/diversity.py)时 chat 路自动做 MMR+ 多样性选择(权重仍取 MEMORY_HYBRID_V2_MMR_LAMBDA);+ limit >= 20 时跳过 MMR(O(k²·pool) 的 Jaccard 贪心,+ 大 k 下代价高、收益小)。重排池是 limit 的若干倍,但判定+ 只看调用方给的 limit。min_score: **chat 路专用**的最低分数阈值,默认 0.4。working 路不看这个值,两层各有自己的阈值(见下两项)。working_fact_min_score:@@ -1854,6 +1925,11 @@ class HyMemoryClient:layers: 可选。pro/ultra 下只召回指定层级(字符串或MemoryLayer),在召回阶段生效。lite 下忽略该参数并强制只召回 L1_RAW。+ rerank: 默认 True(原行为)。False 时本次调用跳过全部重排阶段:+ chat 路的本地 cross-encoder 重排(recall.local_rerank_enabled)+ 与记忆关系图重排(graph_rerank / episode 扩展),working/+ coding 路事实层的 BM25 词面融合重排;结果按召回分排序。+ 按次生效(随请求对象下传),并发 search 互不影响。Returns:chat 路径:{"request_id": "...", "memories": [...], "elapsed_ms": ...}@@ -1865,6 +1941,20 @@ class HyMemoryClient:"chain_used" —— 已挂进 chain_block 的 facts 下标列表。facts **没有**被去重过(不悄悄少给);需要"块 + 剩余 fact" 的拼法就按这个列表自行过滤。+ scene="all":{"request_id", "scene": "all",+ "memories": [统一条目...],+ "lanes": {"chat": n, "working": n, "coding": n}, # 各路参与融合的候选数+ "errors": {lane: "原因"}, # 失败/未启用的路,全成功时为 {}+ "elapsed_ms"}+ 统一条目在各路原字段之上加/覆盖:+ "scene" "chat" | "working" | "coding"+ "kind" "chat" | "experience" | "fact"+ "memory_id" chat 的 memory_id / experience_id / fact_id+ "content" chat 正文;经验为 "task\nsolution";事实为 statement+ "score" RRF 融合分;"lane_score" 为该路原始分;"lane_rank" 为该路名次+ "source", "created_at", "updated_at"(秒级 epoch,取不到为 None)+ chat 路内部名次:normal → schema → proactive 依次排;working/coding 路+ 内部名次:事实与经验各按原顺序交替(事实在前),两层谁也不压谁。"""return self._search_loop_thread.run(self.async_search(query, queries=queries, scene=scene, search_mode=search_mode,@@ -1880,6 +1970,7 @@ class HyMemoryClient:request_id=request_id, layers=layers,embed_override=embed_override,query_embedding=query_embedding,+ rerank=rerank,))def get(@@ -1912,30 +2003,54 @@ class HyMemoryClient:self,memory_id: str,content: str,+ *,+ kind: Optional[MemoryKind] = None,+ variant: Optional[MemoryVariant] = None,+ task: Optional[str] = None,) -> Dict[str, Any]:"""- 更新记忆内容。+ 更新记忆内容。chat / working / coding 都支持,ID 解析与 get() 相同。Args:- memory_id: 记忆 ID- content: 新内容+ memory_id: 记忆 ID(chat memory_id / experience_id / fact_id)+ content: 新内容。chat → 正文;experience → solution(task 不变);+ fact → statement。+ kind: 可选 namespace("chat" / "experience" / "fact"),消歧用。+ variant: 可选生产力变体("working" / "coding"),消歧用。+ task: 可选,仅经验:同时替换 task(会重嵌检索 key)。Returns:{"success": True, "memory_id": "...", "request_id": "...", "elapsed_ms": ...}+ 生产力条目额外带 "kind" / "variant"。ID 同时命中多个 namespace 时抛+ AmbiguousMemoryIdError。"""- return self._loop_thread.run(self.async_update(memory_id, content))+ return self._loop_thread.run(self.async_update(+ memory_id, content, kind=kind, variant=variant, task=task,+ ))- def delete(self, memory_id: str) -> Dict[str, Any]:+ def delete(+ self,+ memory_id: str,+ *,+ kind: Optional[MemoryKind] = None,+ variant: Optional[MemoryVariant] = None,+ ) -> Dict[str, Any]:"""- 删除单条记忆。+ 删除单条记忆。chat / working / coding 都支持,ID 解析与 get() 相同。Args:- memory_id: 记忆 ID+ memory_id: 记忆 ID(chat memory_id / experience_id / fact_id)+ kind: 可选 namespace("chat" / "experience" / "fact"),消歧用。+ variant: 可选生产力变体("working" / "coding"),消歧用。Returns:{"success": True, "deleted_count": 1, "request_id": "...", "elapsed_ms": ...}+ 生产力条目额外带 "kind" / "variant"。ID 同时命中多个 namespace 时抛+ AmbiguousMemoryIdError。"""- return self._loop_thread.run(self.async_delete(memory_id))+ return self._loop_thread.run(+ self.async_delete(memory_id, kind=kind, variant=variant)+ )def delete_all(self,@@ -2009,13 +2124,27 @@ class HyMemoryClient:保持兼容,只返回 ACTIVE。可显式读取 SUPERSEDED / SHADOW /NEGATED / CONFLICTED / ARCHIVED;物理删除的节点不会返回。with_evolution: 可选,为当前页条目附加 evolution_chain(默认关闭)。- scene: 可选,列哪一类记忆:"chat" | "coding" | "working"。- "coding"/"working" 列该类全部经验(workspace_id 可再收窄),- 按 updated_at 倒序,total 为真实总数。不传时保持原行为。+ scene: 可选,列哪一类记忆:"chat" | "coding" | "working" | "all"。+ "coding"/"working" 列该类全部经验(workspace_id 可再收窄,+ include_sources/exclude_sources 按 source 列过滤),+ 按 updated_at 倒序,total 为过滤后的真实总数。+ "all" 把 chat(向量库节点,与 memory_stats 的 chat 同口径)+ 与 working/coding 经验合并,按更新时间倒序(chat 取+ gmt_modified,缺省用 gmt_created;经验取 updated_at)分页,+ total 为三路之和。include_sources/exclude_sources/statuses+ 作用于三路(经验只有 ACTIVE,statuses 不含 ACTIVE 时两路为空);+ agent/session/layers 只作用于 chat,workspace_id/branch 只作用+ 于经验。只支持 order="desc"。不传 scene 时保持原行为。Returns:chat 路径: {"vdb": {...}, "graph": {...} | 省略, "elapsed_ms": ...}coding 路径: {"scene": "productivity", "experiences": [...], ...}+ scene="all": {"scene": "all", "memories": [...], "total",+ "totals": {"chat", "working", "coding"}, "errors": {...},+ "limit", "offset", "request_id", "elapsed_ms"}+ 每条带 "scene"、"kind"(chat | experience)、"memory_id"、"content"+ (经验为 "task\nsolution")、"source"、"status"、"created_at"、+ "updated_at"(秒级 epoch),以及该路原有字段。"""return self._loop_thread.run(self.async_list_memories(@@ -3409,6 +3538,226 @@ class HyMemoryClient:# 无事件循环(极少见):同步跳过,不影响主流程logger.debug("[search] no running loop for dedup; skipped")+ @staticmethod+ def _unify_productivity_item(+ item: Dict[str, Any], *, kind: str, scene: str,+ ) -> Dict[str, Any]:+ """生产力经验/事实 → scene="all" 统一条目(保留原字段)。"""+ if kind == "experience":+ task = str(item.get("task") or "").strip()+ solution = str(item.get("solution") or "").strip()+ content = "\n".join(part for part in (task, solution) if part)+ memory_id = item.get("experience_id")+ created = _epoch_seconds(item.get("created_at"), naive_is_utc=True)+ updated = _epoch_seconds(item.get("updated_at"), naive_is_utc=True)+ else:+ content = str(item.get("statement") or "")+ memory_id = item.get("fact_id")+ created = _epoch_seconds(item.get("created_at"), naive_is_utc=True)+ # 事实没有修改时间列:写入后只会被 SUPERSEDE,不会原地改+ updated = created+ return {+ **item,+ "scene": scene,+ "kind": kind,+ "memory_id": memory_id,+ "content": content,+ "source": item.get("source") or "default",+ "created_at": created,+ "updated_at": updated if updated is not None else created,+ }++ @staticmethod+ def _search_lane_items(lane: str, resp: Dict[str, Any]) -> List[Dict[str, Any]]:+ """某一路的 search 结果 → 按本路名次排好的统一条目列表。++ chat:normal → schema → proactive(与 reader 的组装顺序一致)。+ working/coding:事实与经验各按原顺序交替、事实在前。两层本就分开计数+ (各自 ≤ limit),交替让融合后两层都有代表,谁也不压谁。+ """+ out: List[Dict[str, Any]] = []+ if lane == "chat":+ memories = resp.get("memories") or {}+ if isinstance(memories, dict):+ ordered = (+ list(memories.get("normal") or [])+ + list(memories.get("schema") or [])+ + list(memories.get("proactive") or [])+ )+ else:+ ordered = list(memories)+ for mem in ordered:+ created = _epoch_seconds(mem.get("gmt_created"))+ out.append({+ **mem,+ "scene": "chat",+ "kind": "chat",+ "lane_score": mem.get("score"),+ "source": mem.get("source") or "default",+ "created_at": created,+ "updated_at": _epoch_seconds(mem.get("gmt_modified")) or created,+ })+ return out++ facts = [+ HyMemoryClient._unify_productivity_item(f, kind="fact", scene=lane)+ for f in (resp.get("facts") or [])+ ]+ exps = [+ HyMemoryClient._unify_productivity_item(e, kind="experience", scene=lane)+ for e in (resp.get("experiences") or [])+ ]+ for index in range(max(len(facts), len(exps))):+ if index < len(facts):+ out.append(facts[index])+ if index < len(exps):+ out.append(exps[index])+ for item in out:+ item["lane_score"] = item.get("score")+ return out++ @staticmethod+ def _rrf_fuse_lanes(+ lane_items: Dict[str, List[Dict[str, Any]]],+ *,+ limit: int,+ k: int = _SCENE_RRF_K,+ ) -> List[Dict[str, Any]]:+ """按各路自己的名次做 RRF:score = 1 / (k + rank),rank 从 1 起。++ 条目来自不同 namespace,不跨路合并同 id;同分按 _SCENE_LANES 顺序、再按+ 本路名次排,结果稳定。截断到 limit。+ """+ fused: List[Tuple[float, int, int, Dict[str, Any]]] = []+ for lane_order, lane in enumerate(_SCENE_LANES):+ for rank, item in enumerate(lane_items.get(lane) or [], start=1):+ score = 1.0 / (k + rank)+ fused.append((score, lane_order, rank, {+ **item,+ "score": round(score, 6),+ "lane_rank": rank,+ }))+ fused.sort(key=lambda entry: (-entry[0], entry[1], entry[2]))+ return [entry[3] for entry in fused[:max(0, int(limit))]]++ async def _search_all_scenes(+ self,+ query: Optional[str],+ *,+ queries: Optional[List[str]],+ search_mode: str,+ user_ids: List[str],+ agent_ids: List[str],+ session_ids: List[str],+ include_sources: List[str],+ exclude_sources: List[str],+ limit: int,+ min_score: float,+ working_fact_min_score: Optional[float],+ working_experience_min_score: Optional[float],+ schema_min_score: float,+ schema_limit: int,+ intention_limit: int,+ created_after: Optional[float],+ reader: str,+ workspace_id: Optional[str],+ branch: Optional[str],+ request_id: str,+ layers: Optional[List[Any]],+ query_embedding: Optional[List[float]],+ rerank: bool,+ target_query: str,+ lite_mode: bool,+ t0: float,+ ) -> Dict[str, Any]:+ """search(scene="all"):三路并发召回 + RRF 融合。字段见 search() docstring。++ scene 是显式路由,不做 LLM 判类/改写:三路都用 queries[-1](或 query)。+ query 向量只算一次、三路共用。任一路异常只记进 errors,不让整次失败。+ """+ errors: Dict[str, str] = {}+ coding_cfg = getattr(getattr(self, "_config", None), "coding", None)+ coding_enabled = bool(coding_cfg is not None and coding_cfg.enable)++ embedding = query_embedding+ if not embedding:+ try:+ embedding = await self._embed_service.embed(target_query)+ except Exception as e:+ # 每一路自己再 embed 一次(也可能各自失败,届时分别记错)+ logger.warning(f"[search-all] shared embed failed: {e}")+ embedding = None++ async def _chat_lane() -> Dict[str, Any]:+ return await self._async_search_impl(+ query, queries=queries, scene="chat", search_mode=search_mode,+ user_ids=user_ids, agent_ids=agent_ids, session_ids=session_ids,+ include_sources=include_sources, exclude_sources=exclude_sources,+ limit=limit, min_score=min_score,+ schema_min_score=schema_min_score, schema_limit=schema_limit,+ intention_limit=intention_limit, created_after=created_after,+ reader=reader, request_id=request_id, layers=layers,+ query_embedding=embedding, rerank=rerank,+ )++ async def _productivity_lane(variant: str) -> Optional[Dict[str, Any]]:+ # 没写过的场景直接跳过:不为一次检索建空库+ store = await self._coding_store_for_exact_get(variant)+ if store is None:+ return None+ return await self._search_coding(+ target_query,+ user_ids=user_ids, agent_ids=agent_ids, session_ids=session_ids,+ workspace_id=workspace_id, branch=branch, limit=limit,+ working_fact_min_score=working_fact_min_score,+ working_experience_min_score=working_experience_min_score,+ request_id=request_id, t0=t0, variant=variant,+ include_sources=include_sources, exclude_sources=exclude_sources,+ rerank=rerank, query_embedding=embedding,+ )++ lanes_to_run: Dict[str, Any] = {"chat": _chat_lane()}+ for variant in ("working", "coding"):+ if lite_mode:+ errors[variant] = "disabled: lite mode is chat raw-only"+ elif not coding_enabled:+ errors[variant] = "disabled: productivity link disabled in config"+ else:+ lanes_to_run[variant] = _productivity_lane(variant)++ names = list(lanes_to_run)+ results = await asyncio.gather(+ *lanes_to_run.values(), return_exceptions=True,+ )+ lane_items: Dict[str, List[Dict[str, Any]]] = {}+ for name, result in zip(names, results):+ if isinstance(result, BaseException):+ if not isinstance(result, Exception):+ raise result+ logger.warning(f"[search-all] lane {name} failed: {result}")+ errors[name] = f"{type(result).__name__}: {result}"+ continue+ if result is None:+ continue+ lane_items[name] = self._search_lane_items(name, result)++ memories = self._rrf_fuse_lanes(lane_items, limit=limit)+ lanes = {lane: len(lane_items.get(lane) or []) for lane in _SCENE_LANES}+ elapsed = round((time.perf_counter() - t0) * 1000, 2)+ logger.info(+ f"[search-all] lanes={lanes} returned={len(memories)} "+ f"errors={sorted(errors)} rerank={rerank} elapsed_ms={elapsed}"+ )+ out: Dict[str, Any] = {+ "request_id": request_id,+ "scene": "all",+ "memories": memories,+ "lanes": lanes,+ "errors": errors,+ "elapsed_ms": elapsed,+ }+ return out+@_ensure_search_loopasync def async_search(self,@@ -3437,6 +3786,7 @@ class HyMemoryClient:layers: Optional[List[Any]] = None,embed_override: Optional[Dict[str, Any]] = None,query_embedding: Optional[List[float]] = None,+ rerank: bool = True,) -> Dict[str, Any]:"""搜索记忆(异步)。详见 search() docstring。@@ -3465,6 +3815,7 @@ class HyMemoryClient:reader=reader, workspace_id=workspace_id, branch=branch,request_id=request_id, layers=layers,query_embedding=query_embedding,+ rerank=rerank,)return await self._async_search_impl(query, queries=queries, scene=scene, search_mode=search_mode,@@ -3479,6 +3830,7 @@ class HyMemoryClient:reader=reader, workspace_id=workspace_id, branch=branch,request_id=request_id, layers=layers,query_embedding=query_embedding,+ rerank=rerank,)async def _async_search_impl(@@ -3507,6 +3859,7 @@ class HyMemoryClient:request_id: Optional[str] = None,layers: Optional[List[Any]] = None,query_embedding: Optional[List[float]] = None,+ rerank: bool = True,) -> Dict[str, Any]:"""搜索记忆(异步)。详见 search() docstring。@@ -3542,7 +3895,8 @@ class HyMemoryClient:# "chat" → "normal"(走 chat 召回)# "productivity" / "normal" 作为旧别名保留,向后兼容。scene_norm: Optional[str] = None- if scene is not None:+ scene_all = scene is not None and str(scene).strip().lower() == "all"+ if scene is not None and not scene_all:sn = str(scene).strip().lower()_scene_map = {"working": "productivity",@@ -3553,7 +3907,7 @@ class HyMemoryClient:}if sn not in _scene_map:raise ValueError(- f"scene must be 'chat', 'working' or 'coding', got {scene!r}"+ f"scene must be 'chat', 'working', 'coding' or 'all', got {scene!r}")scene_norm = _scene_map[sn]@@ -3589,6 +3943,25 @@ class HyMemoryClient:"Use single agent_id with multiple session_ids, or multiple agent_ids without session_ids.")+ if scene_all:+ return await self._search_all_scenes(+ query, queries=queries, search_mode=search_mode,+ user_ids=effective_user_ids,+ agent_ids=effective_agent_ids,+ session_ids=effective_session_ids,+ include_sources=effective_include_sources,+ exclude_sources=effective_exclude_sources,+ limit=limit, min_score=min_score,+ working_fact_min_score=working_fact_min_score,+ working_experience_min_score=working_experience_min_score,+ schema_min_score=schema_min_score, schema_limit=schema_limit,+ intention_limit=intention_limit, created_after=created_after,+ reader=reader, workspace_id=workspace_id, branch=branch,+ request_id=request_id, layers=layers,+ query_embedding=query_embedding, rerank=rerank,+ target_query=target_query, lite_mode=lite_mode, t0=t0,+ )+# ────────────────────────────────────────────────────────────# Search mode + scene 路由#@@ -3857,6 +4230,7 @@ class HyMemoryClient:variant=decided_variant,include_sources=effective_include_sources,exclude_sources=effective_exclude_sources,+ rerank=rerank,)# ────────────────────────────────────────────────────────────@@ -3924,6 +4298,7 @@ class HyMemoryClient:if effective_search_layers else None),query_embedding=query_embedding,+ rerank=bool(rerank),)reader_impl = await self._registry.get_reader(reader_name=reader)@@ -4121,6 +4496,92 @@ class HyMemoryClient:"elapsed_ms": elapsed_ms,}+ @staticmethod+ def _validate_memory_namespace(+ kind: Optional[str], variant: Optional[str],+ ) -> None:+ if kind not in (None, "chat", "experience", "fact"):+ raise ValueError(+ "kind must be one of: chat, experience, fact"+ )+ if variant not in (None, "working", "coding"):+ raise ValueError("variant must be one of: working, coding")+ if kind == "chat" and variant is not None:+ raise ValueError("variant is only valid for experience/fact lookups")++ async def _resolve_memory_namespace(+ self,+ memory_id: str,+ *,+ kind: Optional[str],+ variant: Optional[str],+ chat_lookups: Dict[str, Any],+ ) -> Tuple[List[Tuple[str, Any]], Dict[str, Any], Dict[str, Any]]:+ """按 kind/variant 在 chat 与 working/coding 的经验/事实里精确查 ID。++ get / update / delete 共用这一套解析:+ - kind/variant 都不给:查 chat + 两个变体的经验和事实+ - variant 给了:只查该变体(不查 chat)+ - kind 给了:只查该类+ 没写过的变体不建空库(_coding_store_for_exact_get)。命中多于一个+ namespace 时 fail closed,抛 AmbiguousMemoryIdError。++ chat_lookups:{"chat:<name>": 零参协程函数},按顺序取第一个非 None 作为+ chat 命中(get 传 vdb + graph,update 只传 vdb)。++ Returns:+ (matches, by_name, stores) —— matches 是 [(namespace, item)],+ namespace 为 "chat" 或 "<variant>:<kind>";by_name 是每次查询的原始+ 结果;stores 是参与查询的 {variant: CodingMemoryStore}。+ """+ query_chat = kind in (None, "chat") and variant is None+ coding_kinds = (+ ("experience", "fact") if kind is None else (kind,)+ )+ coding_variants = (variant,) if variant is not None else ("working", "coding")++ stores: Dict[str, Any] = {}+ if kind != "chat":+ for candidate_variant in coding_variants:+ store = await self._coding_store_for_exact_get(candidate_variant)+ if store is not None:+ stores[candidate_variant] = store++ tasks = []+ task_names: List[str] = []+ if query_chat:+ for name, lookup in chat_lookups.items():+ tasks.append(lookup())+ task_names.append(name)+ for candidate_variant, store in stores.items():+ if "experience" in coding_kinds:+ tasks.append(store.get_by_id(memory_id))+ task_names.append(f"{candidate_variant}:experience")+ if "fact" in coding_kinds:+ tasks.append(store.get_fact(memory_id))+ task_names.append(f"{candidate_variant}:fact")++ values = await asyncio.gather(*tasks) if tasks else []+ by_name = dict(zip(task_names, values))++ matches: List[Tuple[str, Any]] = []+ chat_node = next(+ (by_name[name] for name in chat_lookups+ if by_name.get(name) is not None),+ None,+ )+ if chat_node is not None:+ matches.append(("chat", chat_node))+ for name, value in by_name.items():+ if not name.startswith("chat:") and value is not None:+ matches.append((name, value))++ if len(matches) > 1:+ raise AmbiguousMemoryIdError(+ memory_id, [namespace for namespace, _ in matches]+ )+ return matches, by_name, stores+@_ensure_internal_loopasync def async_get(self,@@ -4144,14 +4605,7 @@ class HyMemoryClient:Returns:统一 memory dict,或 None。"""- if kind not in (None, "chat", "experience", "fact"):- raise ValueError(- "kind must be one of: chat, experience, fact"- )- if variant not in (None, "working", "coding"):- raise ValueError("variant must be one of: working, coding")- if kind == "chat" and variant is not None:- raise ValueError("variant is only valid for experience/fact lookups")+ self._validate_memory_namespace(kind, variant)request_id = str(uuid.uuid4())set_request_id(request_id)@@ -4174,50 +4628,13 @@ class HyMemoryClient:logger.debug(f"[get] graph_store query failed: {e}")return None- query_chat = kind in (None, "chat") and variant is None- coding_kinds = (- ("experience", "fact") if kind is None else (kind,)+ matches, by_name, _stores = await self._resolve_memory_namespace(+ memory_id, kind=kind, variant=variant,+ chat_lookups={"chat:vdb": _get_vdb, "chat:graph": _get_graph},)- coding_variants = (variant,) if variant is not None else ("working", "coding")-- stores = {}- if kind != "chat":- for candidate_variant in coding_variants:- store = await self._coding_store_for_exact_get(candidate_variant)- if store is not None:- stores[candidate_variant] = store-- tasks = []- task_names = []- if query_chat:- tasks.extend((_get_vdb(), _get_graph()))- task_names.extend(("chat:vdb", "chat:graph"))- for candidate_variant, store in stores.items():- if "experience" in coding_kinds:- tasks.append(store.get_by_id(memory_id))- task_names.append(f"{candidate_variant}:experience")- if "fact" in coding_kinds:- tasks.append(store.get_fact(memory_id))- task_names.append(f"{candidate_variant}:fact")-- values = await asyncio.gather(*tasks) if tasks else []- by_name = dict(zip(task_names, values))vdb_node = by_name.get("chat:vdb")graph_node = by_name.get("chat:graph")- matches = []- chat_node = vdb_node if vdb_node is not None else graph_node- if chat_node is not None:- matches.append(("chat", chat_node))- for name, value in by_name.items():- if not name.startswith("chat:") and value is not None:- matches.append((name, value))-- if len(matches) > 1:- raise AmbiguousMemoryIdError(- memory_id, [namespace for namespace, _ in matches]- )-elapsed = round((time.perf_counter() - t0) * 1000, 2)_hit_namespace, _hit_node = matches[0] if matches else ("", None)_source = (@@ -4321,14 +4738,139 @@ class HyMemoryClient:return None@_ensure_internal_loop- async def async_update(self, memory_id: str, content: str) -> Dict[str, Any]:+ async def async_update(+ self,+ memory_id: str,+ content: str,+ *,+ kind: Optional[MemoryKind] = None,+ variant: Optional[MemoryVariant] = None,+ task: Optional[str] = None,+ ) -> Dict[str, Any]:"""更新记忆内容(异步)。- 流程: get_by_id → 404 校验 → embed → 更新节点字段 → upsert → 记录历史+ namespace 解析与 get() 相同(_resolve_memory_namespace):kind/variant 都不+ 给时查 chat + working/coding 的经验与事实,命中多个 namespace 抛+ AmbiguousMemoryIdError,用 kind/variant 消歧。chat 只认向量库里的节点+ (与改动前一致)。++ content 的映射:+ - chat:替换正文并重嵌(原行为)+ - experience:替换 solution(与 get() 返回的 content 同一字段);task+ 不变,除非另传 task=。solution 不进向量,只改它时不重嵌;改了 task+ 则删旧 key 向量行、重嵌 task + search_keys。updated_at 刷新。+ - fact:替换 statement,active 事实重嵌其向量行。+ task= 只对经验有效,给 chat / fact 传会 ValueError。Returns:- {"success", "memory_id", "request_id", "elapsed_ms"}+ {"success", "memory_id", "request_id", "elapsed_ms"};生产力条目额外带+ "kind" / "variant"。不存在时 success=False + error_message。+ """+ self._validate_memory_namespace(kind, variant)+ if task is not None and kind in ("chat", "fact"):+ raise ValueError("task is only valid when updating an experience")+ matches, _, stores = await self._resolve_memory_namespace(+ memory_id, kind=kind, variant=variant,+ chat_lookups={+ "chat:vdb": lambda: self._vector_store.get_by_id(memory_id),+ },+ )+ namespace = matches[0][0] if matches else ""+ if namespace and namespace != "chat":+ hit_variant, hit_kind = namespace.split(":", 1)+ if task is not None and hit_kind != "experience":+ raise ValueError("task is only valid when updating an experience")+ return await self._update_productivity(+ stores[hit_variant], memory_id, content,+ kind=hit_kind, variant=hit_variant, task=task,+ )+ if task is not None:+ raise ValueError("task is only valid when updating an experience")+ if not namespace and (kind not in (None, "chat") or variant is not None):+ return self._productivity_not_found(+ memory_id, kind=kind, variant=variant, op="update",+ )+ return await self._update_chat(memory_id, content)++ @staticmethod+ def _productivity_not_found(+ memory_id: str, *, kind: Optional[str], variant: Optional[str], op: str,+ ) -> Dict[str, Any]:+ request_id = str(uuid.uuid4())+ logger.warning(+ f"[{op}] not found: memory_id={memory_id} kind={kind} variant={variant}"+ )+ out: Dict[str, Any] = {+ "success": False,+ "memory_id": memory_id,+ "kind": kind,+ "variant": variant,+ "request_id": request_id,+ "elapsed_ms": 0.0,+ "error_message": f"memory_id '{memory_id}' not found",+ }+ if op == "delete":+ out.update({"deleted_count": 0, "partial": False, "error_code": None})+ return out++ async def _update_productivity(+ self,+ store,+ memory_id: str,+ content: str,+ *,+ kind: str,+ variant: str,+ task: Optional[str],+ ) -> Dict[str, Any]:+ request_id = str(uuid.uuid4())+ set_request_id(request_id)+ t0 = time.perf_counter()+ logger.info(+ f"[update] memory_id={memory_id} namespace={variant}:{kind} "+ f"new_content({len(content)} chars)"+ )+ if kind == "experience":+ updated = await store.edit_experience(+ memory_id, solution=content, task=task,+ )+ else:+ updated = await store.edit_fact(memory_id, statement=content)+ elapsed = round((time.perf_counter() - t0) * 1000, 2)+ if updated is None:+ # 解析之后、写入之前被并发删掉+ return {+ "success": False,+ "memory_id": memory_id,+ "kind": kind,+ "variant": variant,+ "request_id": request_id,+ "elapsed_ms": elapsed,+ "error_message": f"memory_id '{memory_id}' not found",+ }+ await self._maybe_store_op_log(+ step="UPDATE",+ request_id=request_id,+ user_id=getattr(updated, "user_id", "") or "",+ agent_id=getattr(updated, "agent_id", "") or "",+ parsed={"memory_id": memory_id, "namespace": f"{variant}:{kind}"},+ memory_ids=[memory_id],+ elapsed_ms=elapsed,+ )+ return {+ "success": True,+ "memory_id": memory_id,+ "kind": kind,+ "variant": variant,+ "request_id": request_id,+ "elapsed_ms": elapsed,+ }++ async def _update_chat(self, memory_id: str, content: str) -> Dict[str, Any]:+ """chat 记忆的更新(原 async_update 逻辑)。++ 流程: get_by_id → 404 校验 → embed → 更新节点字段 → upsert → 记录历史"""request_id = str(uuid.uuid4())set_request_id(request_id)@@ -4471,10 +5013,104 @@ class HyMemoryClient:logger.debug(f"[{step.lower()}] store op trace failed (non-fatal): {e}")@_ensure_internal_loop- async def async_delete(self, memory_id: str) -> Dict[str, Any]:+ async def async_delete(+ self,+ memory_id: str,+ *,+ kind: Optional[MemoryKind] = None,+ variant: Optional[MemoryVariant] = None,+ ) -> Dict[str, Any]:"""删除单条记忆(异步)。+ namespace 解析与 get() 相同:kind/variant 都不给时查 chat(向量库 + 图库)+ 与 working/coding 的经验和事实,命中多个 namespace 抛+ AmbiguousMemoryIdError。++ - chat:原逻辑(见 _delete_chat)+ - experience:删 SQLite 行 + 经验向量集合里它的全部 key 行+ - fact:删 SQLite 行 + 事实向量集合里那一行;别处指向它的引用不清,+ 召回侧本就按存在性过滤死链++ Returns:+ {"success", "deleted_count", "request_id", "elapsed_ms", ...};+ 生产力条目额外带 "kind" / "variant"。不存在时 success=False、+ deleted_count=0。+ """+ self._validate_memory_namespace(kind, variant)++ async def _get_graph():+ if getattr(self, "_graph_store", None) is None:+ return None+ try:+ return await self._graph_store.get_node(memory_id)+ except Exception:+ # 图库查不通交给 _delete_chat 报 delete_incomplete+ return None++ matches, _, stores = await self._resolve_memory_namespace(+ memory_id, kind=kind, variant=variant,+ chat_lookups={+ "chat:vdb": lambda: self._vector_store.get_by_id(memory_id),+ "chat:graph": _get_graph,+ },+ )+ namespace = matches[0][0] if matches else ""+ if namespace and namespace != "chat":+ hit_variant, hit_kind = namespace.split(":", 1)+ return await self._delete_productivity(+ stores[hit_variant], memory_id, matches[0][1],+ kind=hit_kind, variant=hit_variant,+ )+ if not namespace and (kind not in (None, "chat") or variant is not None):+ return self._productivity_not_found(+ memory_id, kind=kind, variant=variant, op="delete",+ )+ return await self._delete_chat(memory_id)++ async def _delete_productivity(+ self, store, memory_id: str, item, *, kind: str, variant: str,+ ) -> Dict[str, Any]:+ request_id = str(uuid.uuid4())+ set_request_id(request_id)+ t0 = time.perf_counter()+ logger.info(f"[delete] memory_id={memory_id} namespace={variant}:{kind}")+ user_id = getattr(item, "user_id", "") or ""+ if kind == "experience":+ deleted = await store.delete(memory_id, user_id=user_id)+ else:+ deleted = await store.delete_fact(memory_id, user_id=user_id or None)+ elapsed = round((time.perf_counter() - t0) * 1000, 2)+ await self._maybe_store_op_log(+ step="DELETE",+ request_id=request_id,+ user_id=user_id,+ agent_id=getattr(item, "agent_id", "") or "",+ parsed={+ "memory_id": memory_id,+ "namespace": f"{variant}:{kind}",+ "found": True,+ "deleted_count": 1 if deleted else 0,+ },+ memory_ids=[memory_id],+ elapsed_ms=elapsed,+ )+ return {+ "success": bool(deleted),+ "deleted_count": 1 if deleted else 0,+ "memory_id": memory_id,+ "kind": kind,+ "variant": variant,+ "partial": False,+ "error_code": None,+ "request_id": request_id,+ "elapsed_ms": elapsed,+ }++ async def _delete_chat(self, memory_id: str) -> Dict[str, Any]:+ """+ 删除单条 chat 记忆(原 async_delete 逻辑)。+同时删除向量库和图数据库(如有)中的对应节点。演化链处理:@@ -5210,6 +5846,8 @@ class HyMemoryClient:t0: float,statuses: Optional[List] = None,variant: Optional[str] = None,+ include_sources: Optional[List[str]] = None,+ exclude_sources: Optional[List[str]] = None,) -> Dict[str, Any]:"""按 workspace_id(+可选 branch)纯过滤列出经验层完整详情。@@ -5218,7 +5856,14 @@ class HyMemoryClient:variant 给定时读该变体自己的库(没写过的变体不建空库,直接返回空),workspace_id 为空表示该 user 的全部经验。未给定时沿用"最近一次用的那份"。++ include_sources / exclude_sources 按 source 列在 SQL 里过滤(排除优先),+ 分页与 total 都在过滤之后计算。"""+ from .utils.source_filter import normalize_source_filters+ include_sources, exclude_sources = normalize_source_filters(+ include_sources, exclude_sources,+ )empty = {"request_id": request_id,"scene": "productivity",@@ -5249,9 +5894,13 @@ class HyMemoryClient:mems = await store.list_by_workspace(user_id=user_id, workspace_id=workspace_id or "", branch=branch,limit=limit, offset=offset,+ include_sources=include_sources or None,+ exclude_sources=exclude_sources or None,)total = (await store.stats(user_id, workspace_id=workspace_id or None, branch=branch,+ include_sources=include_sources or None,+ exclude_sources=exclude_sources or None,))["count"]except Exception as e:logger.warning(f"[list-coding] list_by_workspace failed: {e}")@@ -5298,14 +5947,165 @@ class HyMemoryClient:@staticmethoddef _list_scene(scene: Optional[str]) -> Optional[str]:- """list/stats 的 scene:None(原有路由)| chat | coding | working。"""+ """list/stats 的 scene:None(原有路由)| chat | coding | working | all。"""if scene is None:return Nonevalue = str(scene).strip().lower()- if value not in ("chat", "coding", "working"):- raise ValueError(f"scene must be chat, coding or working, got {scene!r}")+ if value not in ("chat", "coding", "working", "all"):+ raise ValueError(+ f"scene must be chat, coding, working or all, got {scene!r}"+ )return value+ @staticmethod+ def _chat_list_item_unified(node) -> Dict[str, Any]:+ """chat 节点 → list(scene="all") 统一条目(在原 list 条目上加字段)。"""+ item = HyMemoryClient._memory_node_to_list_item(node)+ created = item.get("gmt_created")+ updated = _epoch_seconds(getattr(node, "gmt_modified", None))+ item.update({+ "scene": "chat",+ "kind": "chat",+ "source": item.get("source") or "default",+ "created_at": created,+ "updated_at": updated if updated is not None else created,+ })+ return item++ async def _list_all_scenes(+ self,+ *,+ user_id: str,+ agent_id: Optional[str],+ user_ids: Optional[List[str]],+ agent_ids: Optional[List[str]],+ session_ids: Optional[List[str]],+ include_sources: Optional[List[str]],+ exclude_sources: Optional[List[str]],+ layers: Optional[List],+ statuses: Optional[List],+ workspace_id: Optional[str],+ branch: Optional[str],+ limit: int,+ offset: int,+ order: str,+ request_id: str,+ t0: float,+ ) -> Dict[str, Any]:+ """list_memories(scene="all"):chat + working + coding 按更新时间合并分页。++ 分页做法(k 路归并的前缀):合并序的前 offset+limit 条,必然落在每一路+ 各自的前 offset+limit 条里。所以生产力两路只向 SQLite 要+ ``ORDER BY updated_at DESC LIMIT offset+limit``(有 updated_at 索引),+ total 用 COUNT 聚合;chat 路本来就是整表读回再排序(VDB 没有按时间的+ 有序分页),与 scene=None 的 chat 列表开销相同。三路合并后按+ (updated_at desc, scene, memory_id) 排序再切 [offset, offset+limit)。+ 翻页越深,生产力两路取的前缀越长(O(offset+limit)),但从不整表扫描。+ """+ from .models.memory import MemoryStatus+ from .utils.source_filter import normalize_source_filters++ if str(order or "desc").strip().lower() != "desc":+ raise ValueError("list_memories(scene='all') only supports order='desc'")+ include, exclude = normalize_source_filters(include_sources, exclude_sources)+ window = max(0, int(offset)) + max(0, int(limit))++ nodes = await self._list_vdb_nodes(+ user_id=user_id, agent_id=agent_id,+ user_ids=user_ids, agent_ids=agent_ids,+ session_ids=session_ids,+ include_sources=include or None,+ exclude_sources=exclude or None,+ layers=layers, statuses=statuses,+ )+ # 排序键 (-更新时间(亚秒精度), 路序, 本路名次):本路名次就是该路自己的+ # 排序(生产力路 = SQL 的 updated_at DESC, experience_id ASC),这样合并序+ # 在每一路内部与那一路的取数顺序一致,"只取每路前 offset+limit 条" 才严格成立。+ lane_order = {lane: index for index, lane in enumerate(_SCENE_LANES)}+ keyed: List[Tuple[Tuple[float, int, int], Dict[str, Any]]] = []++ def _chat_ts(node) -> float:+ for value in (+ getattr(node, "gmt_modified", None),+ getattr(node, "gmt_created", None),+ getattr(node, "valid_from", None),+ ):+ stamp = _epoch_float(value)+ if stamp is not None:+ return stamp+ return float("-inf")++ chat_sorted = sorted(+ nodes, key=lambda n: (-_chat_ts(n), str(getattr(n, "node_id", "")))+ )+ for position, node in enumerate(chat_sorted):+ keyed.append((+ (-_chat_ts(node), lane_order["chat"], position),+ self._chat_list_item_unified(node),+ ))+ totals: Dict[str, int] = {"chat": len(nodes), "working": 0, "coding": 0}+ errors: Dict[str, str] = {}++ include_productivity = not statuses or MemoryStatus.ACTIVE in statuses+ productivity_user = user_id or (user_ids[0] if user_ids else "")+ for variant in ("working", "coding"):+ if not include_productivity:+ continue+ try:+ store = await self._coding_store_for_exact_get(variant)+ if store is None:+ continue+ mems = await store.list_by_workspace(+ user_id=productivity_user,+ workspace_id=workspace_id or "", branch=branch,+ limit=window, offset=0,+ include_sources=include or None,+ exclude_sources=exclude or None,+ )+ totals[variant] = int((await store.stats(+ productivity_user,+ workspace_id=workspace_id or None, branch=branch,+ include_sources=include or None,+ exclude_sources=exclude or None,+ ))["count"])+ except Exception as e:+ logger.warning(f"[list-all] {variant} lane failed: {e}")+ errors[variant] = f"{type(e).__name__}: {e}"+ continue+ for position, d in enumerate(mems):+ payload = d.to_dict()+ payload["status"] = MemoryStatus.ACTIVE.value+ stamp = _epoch_float(+ d.updated_at or d.created_at, naive_is_utc=True,+ )+ keyed.append((+ (-(stamp if stamp is not None else float("-inf")),+ lane_order[variant], position),+ self._unify_productivity_item(+ payload, kind="experience", scene=variant,+ ),+ ))++ keyed.sort(key=lambda entry: entry[0])+ page = [item for _, item in keyed[offset: offset + limit]]+ total = sum(totals.values())+ elapsed = round((time.perf_counter() - t0) * 1000, 2)+ logger.info(+ f"[list-all] user={user_ids or user_id} totals={totals} "+ f"returned={len(page)} offset={offset} limit={limit} elapsed={elapsed}ms"+ )+ return {+ "request_id": request_id,+ "scene": "all",+ "memories": page,+ "total": total,+ "totals": totals,+ "errors": errors,+ "limit": limit,+ "offset": offset,+ "elapsed_ms": elapsed,+ }+@_ensure_internal_loopasync def async_memory_stats(self,@@ -5356,8 +6156,8 @@ class HyMemoryClient:raw = await store.stats(user_id)stats = {"count": raw["count"],- "latest_created_at": _epoch(raw["latest_created_at"]),- "latest_updated_at": _epoch(raw["latest_updated_at"]),+ "latest_created_at": _epoch_seconds(raw["latest_created_at"], naive_is_utc=True),+ "latest_updated_at": _epoch_seconds(raw["latest_updated_at"], naive_is_utc=True),"facts": raw["facts"],}scenes[variant] = stats@@ -5463,6 +6263,7 @@ class HyMemoryClient:user_id=user_id, workspace_id=workspace_id, branch=branch,limit=limit, offset=offset, request_id=request_id, t0=t0,statuses=effective_statuses, variant=list_scene,+ include_sources=include_sources, exclude_sources=exclude_sources,)# workspace_id 非空且未指定 scene → 走 coding memory 列表路径(原有行为)if workspace_id and list_scene is None:@@ -5470,9 +6271,21 @@ class HyMemoryClient:user_id=user_id, workspace_id=workspace_id, branch=branch,limit=limit, offset=offset, request_id=request_id, t0=t0,statuses=effective_statuses,+ include_sources=include_sources, exclude_sources=exclude_sources,)effective_layers = self._normalize_layers(layers)+ if list_scene == "all":+ return await self._list_all_scenes(+ user_id=user_id, agent_id=agent_id,+ user_ids=user_ids, agent_ids=agent_ids,+ session_ids=session_ids,+ include_sources=include_sources, exclude_sources=exclude_sources,+ layers=effective_layers, statuses=effective_statuses,+ workspace_id=workspace_id, branch=branch,+ limit=limit, offset=offset, order=order,+ request_id=request_id, t0=t0,+ )vdb = await self._list_vdb_bucket(user_id=user_id, agent_id=agent_id,diff --git a/hy_memory/coding/store.py b/hy_memory/coding/store.pyindex 0f5225c..5503934 100644--- a/hy_memory/coding/store.py+++ b/hy_memory/coding/store.py@@ -217,6 +217,21 @@ def _in_clause(column: str, values: Optional[List[str]]) -> Tuple[str, List[Any]return f"{column} IN ({placeholders})", list(values)+def _source_where(+ include_sources: Optional[List[str]], exclude_sources: Optional[List[str]],+) -> Tuple[str, List[Any]]:+ """Caller-source filter as SQL (``1`` when unfiltered); exclusion wins."""+ clauses: List[str] = []+ params: List[Any] = []+ if include_sources:+ clauses.append(f"source IN ({','.join('?' for _ in include_sources)})")+ params.extend(include_sources)+ if exclude_sources:+ clauses.append(f"source NOT IN ({','.join('?' for _ in exclude_sources)})")+ params.extend(exclude_sources)+ return (" AND ".join(clauses) or "1"), params++def _scope_matches(row_workspace_id: Optional[str],row_branch: Optional[str],@@ -603,6 +618,86 @@ class CodingMemoryStore:logger.info(f"[coding-store] deleted experience_id={experience_id}")return True+ async def edit_experience(+ self,+ experience_id: str,+ *,+ user_id: Optional[str] = None,+ task: Optional[str] = None,+ solution: Optional[str] = None,+ search_keys: Optional[List[str]] = None,+ ) -> Optional[CodingMemory]:+ """调用方手动改一条经验(client.update 用)。返回改后的经验;不存在返回 None。++ 与 update() 的区别:update 是写入链路的覆盖式重写,带写授权校验(同+ agent/session/workspace 才能改);这里是用户对已有条目的直接编辑,只动+ 给定的字段,其余原样保留,因此不做授权校验。++ 向量行只嵌 task + search_keys(solution 不进向量),所以只改 solution 时+ 不重嵌、不碰向量库;改了 task / search_keys 才删旧 key 行重写。+ updated_at 总是刷新。+ """+ prev = await self.get_by_id(experience_id, user_id=user_id)+ if prev is None:+ return None+ updated = deepcopy(prev)+ if task is not None:+ updated.task = task+ if solution is not None:+ updated.solution = solution+ if search_keys is not None:+ updated.search_keys = list(search_keys)+ updated.updated_at = datetime.utcnow()+ await _run_in_pool(self._upsert_sql_sync, updated)+ if updated.task != prev.task or updated.search_keys != prev.search_keys:+ await self._delete_vec_keys_by_count(experience_id, 1 + len(prev.search_keys))+ await self._upsert_vec_keys(updated)+ logger.info(f"[coding-store] edited experience_id={experience_id}")+ return updated++ async def edit_fact(+ self,+ fact_id: str,+ *,+ statement: str,+ user_id: Optional[str] = None,+ ) -> Optional[WorkingFact]:+ """调用方手动改一条事实的 statement。返回改后的事实;不存在返回 None。++ statement 是事实层的检索文本,所以 active 事实会重嵌并覆盖它那一行向量+ (node_id 就是 fact_id,upsert 即覆盖)。superseded 事实的向量行早已撤掉,+ 这里不把它加回去,否则会让过期结论重新占召回名额。+ """+ prev = await self.get_fact(fact_id, user_id=user_id)+ if prev is None:+ return None+ updated = deepcopy(prev)+ updated.statement = statement+ await _run_in_pool(self._upsert_fact_sql_sync, updated)+ if updated.status == "active":+ await self._upsert_fact_vec(updated)+ logger.info(f"[coding-store] edited fact_id={fact_id}")+ return updated++ async def delete_fact(self, fact_id: str, user_id: Optional[str] = None) -> bool:+ """物理删除一条事实(SQLite 行 + 事实向量行),返回是否真有删到。++ 别处留下的引用(经验的 source_fact_ids、后继事实的 fact_link)不清:+ 召回侧本来就按存在性过滤死链(get_many / get_facts 查不到自然掉队)。+ """+ prev = await self.get_fact(fact_id, user_id=user_id)+ if prev is None:+ logger.info(f"[coding-store] delete fact skipped (not found): {fact_id}")+ return False+ if self._fact_vec is not None:+ try:+ await self._fact_vec.delete(fact_id)+ except Exception as e:+ logger.debug(f"[coding-store] delete fact vec {fact_id} ignored: {e}")+ await _run_in_pool(self._delete_fact_sql_sync, fact_id, prev.user_id)+ logger.info(f"[coding-store] deleted fact_id={fact_id}")+ return True+# ------------------------------------------------------------# 读取# ------------------------------------------------------------@@ -687,26 +782,35 @@ class CodingMemoryStore:branch: Optional[str] = None,limit: int = 100,offset: int = 0,+ include_sources: Optional[List[str]] = None,+ exclude_sources: Optional[List[str]] = None,) -> List["CodingMemory"]:"""按 workspace_id(+可选 branch)纯过滤列出该 user 的完整 coding memory。作用域规则见 _scope_where(与 search 路径共用同一套)。无语义排序,按- updated_at 倒序(最近修改优先)。+ updated_at 倒序(最近修改优先)。include_sources / exclude_sources 按+ source 列在 SQL 里过滤(排除优先),所以 LIMIT/OFFSET 在过滤之后生效。"""return await _run_in_pool(- self._list_by_workspace_sync, user_id, workspace_id, branch, limit, offset+ self._list_by_workspace_sync, user_id, workspace_id, branch, limit, offset,+ include_sources, exclude_sources,)def _list_by_workspace_sync(self, user_id: str, workspace_id: str, branch: Optional[str],limit: int, offset: int,+ include_sources: Optional[List[str]] = None,+ exclude_sources: Optional[List[str]] = None,) -> List["CodingMemory"]:scope_sql, scope_params = _scope_where(workspace_id, branch)+ source_sql, source_params = _source_where(include_sources, exclude_sources)with self._lock:assert self._conn is not Nonesql = (f"SELECT * FROM coding_memory_meta WHERE user_id = ? AND {scope_sql} "- f"ORDER BY updated_at DESC LIMIT ? OFFSET ?")- params: List[Any] = [user_id] + scope_params + [limit, offset]+ f"AND {source_sql} "+ f"ORDER BY updated_at DESC, experience_id ASC LIMIT ? OFFSET ?")+ params: List[Any] = ([user_id] + scope_params + source_params+ + [limit, offset])cur = self._conn.execute(sql, params)return [_row_to_memory(r) for r in cur.fetchall()]@@ -715,29 +819,39 @@ class CodingMemoryStore:user_id: str,workspace_id: Optional[str] = None,branch: Optional[str] = None,+ include_sources: Optional[List[str]] = None,+ exclude_sources: Optional[List[str]] = None,) -> Dict[str, Any]:"""经验数、最新创建/修改时间、active 事实数。纯聚合,不读正文。- 作用域与 list_by_workspace 相同:workspace_id 为空表示该 user 全部。+ 作用域与 list_by_workspace 相同:workspace_id 为空表示该 user 全部;+ 来源过滤同样与 list_by_workspace 一致,count 因此恒等于分页可翻到的总数。"""- return await _run_in_pool(self._stats_sync, user_id, workspace_id, branch)+ return await _run_in_pool(+ self._stats_sync, user_id, workspace_id, branch,+ include_sources, exclude_sources,+ )def _stats_sync(self, user_id: str, workspace_id: Optional[str], branch: Optional[str],+ include_sources: Optional[List[str]] = None,+ exclude_sources: Optional[List[str]] = None,) -> Dict[str, Any]:scope_sql, scope_params = _scope_where(workspace_id, branch)+ source_sql, source_params = _source_where(include_sources, exclude_sources)with self._lock:assert self._conn is not Nonerow = self._conn.execute(f"SELECT COUNT(*) AS n, MAX(created_at) AS created, "f"MAX(updated_at) AS updated FROM coding_memory_meta "- f"WHERE user_id = ? AND {scope_sql}",- [user_id] + scope_params,+ f"WHERE user_id = ? AND {scope_sql} AND {source_sql}",+ [user_id] + scope_params + source_params,).fetchone()facts = self._conn.execute(f"SELECT COUNT(*) AS n FROM working_fact "- f"WHERE user_id = ? AND status = 'active' AND {scope_sql}",- [user_id] + scope_params,+ f"WHERE user_id = ? AND status = 'active' AND {scope_sql} "+ f"AND {source_sql}",+ [user_id] + scope_params + source_params,).fetchone()return {"count": int(row["n"] or 0),@@ -1124,6 +1238,14 @@ class CodingMemoryStore:(experience_id, user_id),)+ def _delete_fact_sql_sync(self, fact_id: str, user_id: str) -> None:+ with self._lock:+ assert self._conn is not None+ self._conn.execute(+ "DELETE FROM working_fact WHERE fact_id = ? AND user_id = ?",+ (fact_id, user_id),+ )+def _get_by_id_sync(self, experience_id: str, user_id: Optional[str]) -> Optional[CodingMemory]:diff --git a/hy_memory/pipelines/_retrieval/diversity.py b/hy_memory/pipelines/_retrieval/diversity.pyindex 34b99af..b81ede6 100644--- a/hy_memory/pipelines/_retrieval/diversity.py+++ b/hy_memory/pipelines/_retrieval/diversity.py@@ -160,6 +160,17 @@ def near_dup_demote(return out+# MMR 只在调用方请求的 top-k(search 的 limit)小于这个值时自动启用。+# mmr_select 的贪心是 O(k^2 * pool) 次 Jaccard,k 大时代价陡增,而大 k 本身已+# 足够容纳多样性,收益很小。权重仍由 MEMORY_HYBRID_V2_MMR_LAMBDA 控制。+MMR_MAX_TOP_K = 20+++def mmr_applies(top_k: int, lambda_: float) -> bool:+ """本次检索是否走 MMR:λ 在有效区间内,且 top_k < MMR_MAX_TOP_K。"""+ return 0.0 < float(lambda_) < 0.999 and int(top_k) < MMR_MAX_TOP_K++def mmr_select(hits: Sequence[Dict[str, Any]],limit: int,diff --git a/hy_memory/pipelines/base.py b/hy_memory/pipelines/base.pyindex e3c57b3..427f3a3 100644--- a/hy_memory/pipelines/base.py+++ b/hy_memory/pipelines/base.py@@ -401,6 +401,11 @@ class ReadRequest:intention_limit: int = 0 # Intention 路的 topk,默认 0 关闭+ # 重排开关(按次生效)。False 时跳过全部重排阶段:本地 cross-encoder+ # (recall.local_rerank_enabled) 与记忆关系图重排 (_apply_graph_rerank),+ # 结果按召回分排序。走请求对象而非环境变量,并发请求互不影响。+ rerank: bool = True+# 时间过滤created_after: Optional[float] = None # Unix timestamp (float),只返回 gmt_created >= 此值的记忆diff --git a/hy_memory/pipelines/reader_base.py b/hy_memory/pipelines/reader_base.pyindex 5a5180b..afeab3c 100644--- a/hy_memory/pipelines/reader_base.py+++ b/hy_memory/pipelines/reader_base.py@@ -58,6 +58,7 @@ from ._retrieval.ner import ()from ._retrieval.diversity import (near_dup_demote,+ mmr_applies,mmr_select,social_boilerplate_demote,pool_df_demote,@@ -1279,7 +1280,10 @@ class BaseReadPipeline(ReadPipeline):SAME_SERIES_TIMELINE_ON = bool(getattr(self.config.recall, "same_series_timeline_enabled", False))- LOCAL_RERANK_ON = bool(+ # 按次的重排开关(search(rerank=False)):关掉本地 cross-encoder 与图重排,+ # 结果按召回分排序。只读请求对象,不碰共享状态,并发请求互不影响。+ RERANK_ON = bool(getattr(request, "rerank", True))+ LOCAL_RERANK_ON = RERANK_ON and bool(getattr(self.config.recall, "local_rerank_enabled", False))LOCAL_RERANK_POOL_FACTOR = max(1, int(@@ -1431,6 +1435,9 @@ class BaseReadPipeline(ReadPipeline):MIN_SCORE = _resolve_normal_min_score(request.min_score)final_limit = request.limit if request.limit > 0 else 10+ # MMR 只在调用方的 top-k(final_limit,即 search 的 limit)< MMR_MAX_TOP_K+ # 时启用;池子(LOCAL_RERANK 下是 final_limit 的若干倍)不参与判定。+ MMR_ON = mmr_applies(final_limit, MMR_LAMBDA)vdb_sem_limit = max(final_limit * 3, 30)vdb_kw_limit = max(final_limit * 5, 80)graph_limit = max(@@ -2462,7 +2469,7 @@ class BaseReadPipeline(ReadPipeline):# 只把已选出的 top-N 换个顺序收益很小。relation_paths: List[Dict[str, Any]] = []_graph_stats: Dict[str, Any] = {}- if self._expansion_on():+ if RERANK_ON and self._expansion_on():_t_graph = datetime.now()_pool_before = len(normal_results)normal_results, relation_paths, _graph_stats = await self._apply_graph_rerank(@@ -2538,7 +2545,7 @@ class BaseReadPipeline(ReadPipeline):))if LOCAL_RERANK_ON else final_limit)- if 0.0 < MMR_LAMBDA < 0.999 and len(normal_results) > _pre_rerank_limit:+ if MMR_ON and len(normal_results) > _pre_rerank_limit:normal_results = mmr_select(normal_results,_pre_rerank_limit,@@ -2715,7 +2722,7 @@ class BaseReadPipeline(ReadPipeline):reverse=True,)if (- 0.0 < MMR_LAMBDA < 0.999+ MMR_ONand len(multi_seed_pool) > _pre_rerank_limit):multi_seed_pool = mmr_select(@@ -3544,6 +3551,8 @@ class BaseReadPipeline(ReadPipeline):"episode_capsule_render_mode": EPISODE_CAPSULE_RENDER_MODE,"same_series_timeline_enabled": SAME_SERIES_TIMELINE_ON,"local_rerank_enabled": LOCAL_RERANK_ON,+ "rerank": RERANK_ON,+ "mmr_applied": MMR_ON,"local_rerank_model": getattr(self.config.recall,"local_rerank_model",diff --git a/hy_memory/server.py b/hy_memory/server.pyindex 4d51487..e18ccab 100644--- a/hy_memory/server.py+++ b/hy_memory/server.py@@ -33,9 +33,28 @@ import threadingfrom datetime import datetimefrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServerfrom typing import Any, Dict, Optional+from urllib.parse import parse_qs, urlparse++from .retrieval import AmbiguousMemoryIdErrorlogger = logging.getLogger("hy_memory.server")++def _namespace_args(values: Dict[str, Any]) -> Dict[str, Any]:+ """kind / variant from a query string (lists) or a JSON body (scalars).++ They disambiguate an id that exists in more than one namespace (chat,+ experience, fact; working or coding). Absent means "resolve it".+ """+ args: Dict[str, Any] = {}+ for key in ("kind", "variant"):+ value = values.get(key)+ if isinstance(value, list):+ value = value[0] if value else None+ if value:+ args[key] = str(value)+ return args+# Lazy-init global client_client = None_client_lock = None@@ -148,7 +167,6 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):if path == "/api/v1/metrics":minutes = 5if "?" in self.path:- from urllib.parse import parse_qs, urlparseqs = parse_qs(urlparse(self.path).query)minutes = int(qs.get("minutes", ["5"])[0])client = _get_client()@@ -161,7 +179,8 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):if m:memory_id = m.group(1)client = _get_client()- result = client.get(memory_id)+ query = parse_qs(urlparse(self.path).query)+ result = client.get(memory_id, **_namespace_args(query))if result is None:_json_response(self, 404, {"error": "not_found", "memory_id": memory_id})else:@@ -170,6 +189,10 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):_json_response(self, 404, {"error": "not_found", "path": path})+ except AmbiguousMemoryIdError as e:+ _json_response(self, 409, {"error": "ambiguous_memory_id", "detail": str(e)})+ except ValueError as e:+ _json_response(self, 400, {"error": str(e)})except Exception as e:logger.error(f"[server] GET {path} error: {e}", exc_info=True)_json_response(self, 500, {"error": str(e)})@@ -213,7 +236,7 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):_json_response(self, 500, {"error": str(e)})def do_PUT(self):- path = self.path.rstrip("/")+ path = self.path.split("?")[0].rstrip("/")body = _read_json_body(self)if body is None:_json_response(self, 400, {"error": "invalid JSON body"})@@ -228,29 +251,43 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):_json_response(self, 400, {"error": "content is required"})returnclient = _get_client()- result = client.update(memory_id, content)+ result = client.update(+ memory_id,+ content,+ **_namespace_args(body),+ **({"task": body["task"]} if body.get("task") else {}),+ )_json_response(self, 200, result)return_json_response(self, 404, {"error": "not_found", "path": path})+ except AmbiguousMemoryIdError as e:+ _json_response(self, 409, {"error": "ambiguous_memory_id", "detail": str(e)})+ except ValueError as e:+ _json_response(self, 400, {"error": str(e)})except Exception as e:logger.error(f"[server] PUT {path} error: {e}", exc_info=True)_json_response(self, 500, {"error": str(e)})def do_DELETE(self):- path = self.path.rstrip("/")+ path = self.path.split("?")[0].rstrip("/")try:m = re.match(r"^/api/v1/memories/([^/]+)$", path)if m:memory_id = m.group(1)client = _get_client()- result = client.delete(memory_id)+ query = parse_qs(urlparse(self.path).query)+ result = client.delete(memory_id, **_namespace_args(query))_json_response(self, 200, result)return_json_response(self, 404, {"error": "not_found", "path": path})+ except AmbiguousMemoryIdError as e:+ _json_response(self, 409, {"error": "ambiguous_memory_id", "detail": str(e)})+ except ValueError as e:+ _json_response(self, 400, {"error": str(e)})except Exception as e:logger.error(f"[server] DELETE {path} error: {e}", exc_info=True)_json_response(self, 500, {"error": str(e)})@@ -455,7 +492,8 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):if key in body:kwargs[key] = body[key]- for key in ("limit", "min_score", "schema_min_score", "schema_limit", "reader"):+ for key in ("limit", "min_score", "schema_min_score", "schema_limit", "reader",+ "rerank"):if key in body:kwargs[key] = body[key]diff --git a/tests/coding/test_all_scenes.py b/tests/coding/test_all_scenes.pynew file mode 100644index 0000000..e3328e9--- /dev/null+++ b/tests/coding/test_all_scenes.py@@ -0,0 +1,665 @@+# -*- coding: utf-8 -*-+"""scene="all"(search / list)与生产力条目的 update / delete。++客户端用 object.__new__(HyMemoryClient) 搭最小骨架,公开 async_* 方法通过+__wrapped__ 直接调(不需要 client 自己的 loop 线程),与+test_list_and_stats_by_scene.py 同一套写法。+"""++from datetime import datetime, timedelta, timezone+from types import SimpleNamespace++import pytest++from hy_memory.client import _SCENE_RRF_K, HyMemoryClient+from hy_memory.coding.store import CodingMemoryStore+from hy_memory.coding.types import CodingMemory, WorkingFact+from hy_memory.models.memory import MemoryLayer, MemoryStatus+from hy_memory.retrieval import AmbiguousMemoryIdError++BASE = datetime(2026, 10, 20, 8, 0, 0)+++def _unwrapped(name):+ return getattr(HyMemoryClient, name).__wrapped__+++async def _store(coding_config, mock_embed, variant):+ store = CodingMemoryStore(coding_config, embed_service=mock_embed, variant=variant)+ await store.initialize()+ return store+++async def _noop(*_args, **_kwargs):+ return None+++def _client(coding_config, mock_embed, stores, *, nodes=()):+ client = object.__new__(HyMemoryClient)+ client._config = coding_config+ client._coding_stores = dict(stores)+ client._embed_service = mock_embed+ client._cache = None+ client._graph_store = None+ client._history_store = None+ client._vector_store = _FakeVectorStore(list(nodes))+ client._get_coding_writer = _noop+ client._maybe_store_op_log = _noop+ client._decorate_with_chain = lambda *a, **k: ("", [])+ return client+++class _FakeVectorStore:+ def __init__(self, nodes):+ self.nodes = {n.node_id: n for n in nodes}++ async def list_by_user(self, *, layers=None, **_):+ if layers == [MemoryLayer.L0_BASIC_INFO]:+ return []+ return list(self.nodes.values())++ async def get_by_id(self, memory_id):+ return self.nodes.get(memory_id)+++def _chat_node(node_id, *, created, modified=None, source="cursor"):+ return SimpleNamespace(+ node_id=node_id, layer=MemoryLayer.L2_FACT, status=MemoryStatus.ACTIVE,+ content=f"chat {node_id}", memory_at=None,+ gmt_created=created, gmt_modified=modified, valid_from=None,+ user_id="u", agent_id="a", session_id="s", source=source,+ speculate=None, tags=[], custom={},+ )+++# ================================================================+# search(scene="all")+# ================================================================++def _chat_resp(*ids):+ return {+ "request_id": "r",+ "memories": {+ "normal": [+ {"memory_id": i, "content": f"chat {i}", "score": 0.9 - n * 0.1,+ "gmt_created": 1_700_000_000 + n, "source": "cursor"}+ for n, i in enumerate(ids)+ ],+ "schema": [],+ "proactive": [],+ },+ }+++def _prod_resp(facts=(), exps=()):+ return {+ "request_id": "r",+ "scene": "productivity",+ "facts": [+ {"fact_id": f, "statement": f"stmt {f}", "score": 0.5,+ "created_at": "2026-10-20T08:00:00", "source": "claude"}+ for f in facts+ ],+ "experiences": [+ {"experience_id": e, "task": f"task {e}", "solution": f"sol {e}",+ "score": 0.7, "updated_at": "2026-10-20T09:00:00", "source": "claude"}+ for e in exps+ ],+ }+++def _fake_all_client(*, chat, working=None, coding=None, fail=(), enable=True,+ seen=None):+ """_search_all_scenes 的依赖全部换成桩:只测融合与容错。"""+ client = object.__new__(HyMemoryClient)+ client._config = SimpleNamespace(coding=SimpleNamespace(enable=enable))++ class _Embed:+ calls = 0++ async def embed(self, text):+ _Embed.calls += 1+ return [0.1, 0.2]++ client._embed_service = _Embed()+ seen = seen if seen is not None else {}++ async def _impl(query, **kw):+ seen["chat"] = kw+ if "chat" in fail:+ raise RuntimeError("chat backend down")+ return chat++ async def _coding_store(variant):+ return object() if {"working": working, "coding": coding}[variant] is not None else None++ async def _search_coding(target_query, **kw):+ seen[kw["variant"]] = kw+ if kw["variant"] in fail:+ raise RuntimeError(f"{kw['variant']} store broken")+ return {"working": working, "coding": coding}[kw["variant"]]++ client._async_search_impl = _impl+ client._coding_store_for_exact_get = _coding_store+ client._search_coding = _search_coding+ return client, seen+++async def _search_all(client, **kw):+ params = dict(+ queries=None, search_mode="default", user_ids=["u"], agent_ids=[],+ session_ids=[], include_sources=["claude"], exclude_sources=["mixed"],+ limit=10, min_score=0.4, working_fact_min_score=None,+ working_experience_min_score=None, schema_min_score=0.4, schema_limit=10,+ intention_limit=0, created_after=None, reader="", workspace_id=None,+ branch=None, request_id="req", layers=None, query_embedding=None,+ rerank=True, target_query="q", lite_mode=False, t0=0.0,+ )+ params.update(kw)+ return await HyMemoryClient._search_all_scenes(client, "q", **params)+++async def test_search_all_fuses_by_lane_rank_with_rrf():+ client, seen = _fake_all_client(+ chat=_chat_resp("c1", "c2", "c3"),+ working=_prod_resp(facts=["wf1"], exps=["we1", "we2"]),+ coding=_prod_resp(exps=["ce1"]),+ )++ out = await _search_all(client, rerank=False)++ assert out["scene"] == "all"+ assert out["request_id"] == "req"+ assert out["lanes"] == {"chat": 3, "working": 3, "coding": 1}+ assert out["errors"] == {}+ order = [(m["scene"], m["memory_id"]) for m in out["memories"]]+ # 名次 1:chat → working → coding(同分按路序),名次 2:chat / working ...+ assert order == [+ ("chat", "c1"), ("working", "wf1"), ("coding", "ce1"),+ ("chat", "c2"), ("working", "we1"),+ ("chat", "c3"), ("working", "we2"),+ ]+ first = out["memories"][0]+ assert first["score"] == round(1.0 / (_SCENE_RRF_K + 1), 6)+ assert first["lane_score"] == pytest.approx(0.9)+ assert first["lane_rank"] == 1 and first["kind"] == "chat"+ fact = out["memories"][1]+ assert fact["kind"] == "fact" and fact["content"] == "stmt wf1"+ assert fact["lane_score"] == 0.5+ exp = out["memories"][4]+ assert exp["kind"] == "experience"+ assert exp["memory_id"] == "we1"+ assert exp["content"] == "task we1\nsol we1"+ assert exp["score"] == round(1.0 / (_SCENE_RRF_K + 2), 6)+ # 生产力时间戳是 naive UTC,按 UTC 换算成 epoch+ assert exp["updated_at"] == int(+ datetime(2026, 10, 20, 9, tzinfo=timezone.utc).timestamp()+ )+ # rerank / 来源过滤 / 阈值传到每一路,query 向量只算一次+ for lane in ("chat", "working", "coding"):+ assert seen[lane]["rerank"] is False+ assert seen[lane]["include_sources"] == ["claude"]+ assert seen[lane]["query_embedding"] == [0.1, 0.2]+ assert seen["chat"]["scene"] == "chat"+ assert client._embed_service.calls == 1+++async def test_search_all_truncates_after_fusion():+ client, _ = _fake_all_client(+ chat=_chat_resp("c1", "c2", "c3"),+ working=_prod_resp(exps=["we1", "we2"]),+ coding=None,+ )+ out = await _search_all(client, limit=3)+ assert [m["memory_id"] for m in out["memories"]] == ["c1", "we1", "c2"]+ # coding 没写过:不贡献、不算错误+ assert out["lanes"]["coding"] == 0+ assert "coding" not in out["errors"]+++async def test_search_all_isolates_a_failing_lane():+ client, _ = _fake_all_client(+ chat=_chat_resp("c1"),+ working=_prod_resp(exps=["we1"]),+ coding=_prod_resp(exps=["ce1"]),+ fail=("working",),+ )+ out = await _search_all(client)+ assert [m["memory_id"] for m in out["memories"]] == ["c1", "ce1"]+ assert out["lanes"] == {"chat": 1, "working": 0, "coding": 1}+ assert "store broken" in out["errors"]["working"]++ client, _ = _fake_all_client(+ chat=_chat_resp("c1"), working=_prod_resp(exps=["we1"]), fail=("chat",),+ )+ out = await _search_all(client)+ assert [m["memory_id"] for m in out["memories"]] == ["we1"]+ assert "chat backend down" in out["errors"]["chat"]+++async def test_search_all_reports_disabled_productivity():+ client, seen = _fake_all_client(+ chat=_chat_resp("c1"), working=_prod_resp(exps=["we1"]), enable=False,+ )+ out = await _search_all(client)+ assert [m["memory_id"] for m in out["memories"]] == ["c1"]+ assert out["lanes"] == {"chat": 1, "working": 0, "coding": 0}+ assert set(out["errors"]) == {"working", "coding"}+ assert "working" not in seen+++async def test_async_search_routes_scene_all(coding_config):+ seen = {}++ async def _spy(query, **kw):+ seen.update(kw)+ return {"scene": "all"}++ client = object.__new__(HyMemoryClient)+ client._config = coding_config+ client._search_all_scenes = _spy+ out = await _unwrapped("async_search")(+ client, "q", scene=" ALL ", user_ids=["u"], include_sources=["Claude"],+ rerank=False, limit=7,+ )+ assert out == {"scene": "all"}+ assert seen["rerank"] is False and seen["limit"] == 7+ assert seen["include_sources"] == ["claude"]+ assert seen["exclude_sources"] == ["mixed"]++ with pytest.raises(ValueError, match="all"):+ await _unwrapped("async_search")(client, "q", scene="every", user_ids=["u"])+++async def test_search_all_productivity_lanes_respect_sources(coding_config, mock_embed):+ """真 store:两路生产力检索按 source 过滤,经验与事实都过。"""+ coding_config.coding.enable = True+ working = await _store(coding_config, mock_embed, "working")+ coding = await _store(coding_config, mock_embed, "coding")+ try:+ await working.insert(CodingMemory(+ experience_id="w-claude", user_id="u", task="deploy service",+ solution="kubectl apply", source="claude",+ ))+ await working.insert(CodingMemory(+ experience_id="w-cursor", user_id="u", task="deploy service",+ solution="helm upgrade", source="cursor",+ ))+ await working.insert_fact(WorkingFact(+ fact_id="f-cursor", user_id="u", statement="deploy service",+ source="cursor",+ ))+ await coding.insert(CodingMemory(+ experience_id="c-claude", user_id="u", task="deploy service",+ solution="make deploy", source="claude",+ ))+ client = _client(coding_config, mock_embed,+ {"working": working, "coding": coding})++ async def _chat(query, **kw):+ return _chat_resp()++ client._async_search_impl = _chat+ out = await _search_all(+ client, target_query="deploy service",+ include_sources=["claude"], exclude_sources=["mixed"],+ )+ ids = {(m["scene"], m["memory_id"]) for m in out["memories"]}+ assert ids == {("working", "w-claude"), ("coding", "c-claude")}+ assert all(m["source"] == "claude" for m in out["memories"])+ finally:+ await working.close()+ await coding.close()+++async def test_productivity_search_rerank_false_skips_fact_lexical_rerank(+ coding_config, mock_embed, monkeypatch,+):+ from hy_memory.coding import lexical++ calls = []+ real = lexical.rerank++ def _spy(*args, **kwargs):+ calls.append(args)+ return real(*args, **kwargs)++ monkeypatch.setattr(lexical, "rerank", _spy)+ working = await _store(coding_config, mock_embed, "working")+ try:+ for index in range(8):+ await working.insert_fact(WorkingFact(+ fact_id=f"f{index}", user_id="u", statement="deploy service",+ ))+ client = _client(coding_config, mock_embed, {"working": working})++ async def _run(rerank):+ return await HyMemoryClient._search_coding(+ client, "deploy service", user_ids=["u"], workspace_id=None,+ branch=None, limit=2, request_id="r", t0=0.0,+ variant="working", rerank=rerank,+ )++ await _run(False)+ assert calls == []+ await _run(True)+ assert len(calls) == 1+ finally:+ await working.close()+++# ================================================================+# list_memories(scene="all") 与生产力 list 的来源过滤+# ================================================================++async def test_list_productivity_scene_filters_sources_with_true_total(+ coding_config, mock_embed,+):+ coding = await _store(coding_config, mock_embed, "coding")+ try:+ for index, source in enumerate(["claude", "cursor", "claude", "Claude"]):+ await coding.insert(CodingMemory(+ experience_id=f"c{index}", user_id="u", task="T", solution="S",+ source=source,+ ))+ client = _client(coding_config, mock_embed, {"coding": coding})+ list_memories = _unwrapped("async_list_memories")++ page = await list_memories(+ client, user_id="u", scene="coding", include_sources=["CLAUDE"], limit=2,+ )+ assert page["total"] == 3+ assert len(page["experiences"]) == 2+ assert all(e["source"] == "claude" for e in page["experiences"])++ page = await list_memories(+ client, user_id="u", scene="coding", exclude_sources=["claude"],+ )+ assert page["total"] == 1+ assert [e["experience_id"] for e in page["experiences"]] == ["c1"]++ unfiltered = await list_memories(client, user_id="u", scene="coding")+ assert unfiltered["total"] == 4+ finally:+ await coding.close()+++async def _seed_all(coding_config, mock_embed):+ coding = await _store(coding_config, mock_embed, "coding")+ working = await _store(coding_config, mock_embed, "working")+ # 生产力时间戳按 UTC 写;这里直接给 updated_at 再改回去(insert 会刷新)+ for eid, hours, source in (("c-old", 1, "claude"), ("c-new", 5, "cursor")):+ await coding.insert(CodingMemory(+ experience_id=eid, user_id="u", task=f"task {eid}", solution="S",+ source=source,+ ))+ await _set_updated(coding, eid, BASE + timedelta(hours=hours))+ await working.insert(CodingMemory(+ experience_id="w-mid", user_id="u", task="task w", solution="W",+ source="claude",+ ))+ await _set_updated(working, "w-mid", BASE + timedelta(hours=3))+ # chat 节点是本地时间 naive;与 UTC 的经验比较时要换算到同一 epoch+ utc_offset = datetime.now() - datetime.utcnow()+ nodes = [+ _chat_node("m-newest", created=BASE + utc_offset + timedelta(hours=6),+ source="claude"),+ _chat_node("m-edited", created=BASE + utc_offset,+ modified=BASE + utc_offset + timedelta(hours=4), source="cursor"),+ _chat_node("m-oldest", created=BASE + utc_offset, source="claude"),+ ]+ return coding, working, nodes+++async def _set_updated(store, experience_id, when):+ def _sync():+ with store._lock:+ store._conn.execute(+ "UPDATE coding_memory_meta SET updated_at = ? WHERE experience_id = ?",+ (when.isoformat(), experience_id),+ )++ _sync()+++async def test_list_all_merges_newest_first_and_paginates(coding_config, mock_embed):+ coding, working, nodes = await _seed_all(coding_config, mock_embed)+ try:+ client = _client(coding_config, mock_embed,+ {"coding": coding, "working": working}, nodes=nodes)+ list_memories = _unwrapped("async_list_memories")++ out = await list_memories(client, user_id="u", scene="all", limit=10)+ assert out["scene"] == "all"+ assert out["total"] == 6+ assert out["totals"] == {"chat": 3, "working": 1, "coding": 2}+ assert [(m["scene"], m["memory_id"]) for m in out["memories"]] == [+ ("chat", "m-newest"),+ ("coding", "c-new"),+ ("chat", "m-edited"),+ ("working", "w-mid"),+ ("coding", "c-old"),+ ("chat", "m-oldest"),+ ]+ exp = out["memories"][1]+ assert exp["kind"] == "experience" and exp["content"] == "task c-new\nS"+ assert exp["status"] == "active"+ assert exp["updated_at"] > out["memories"][2]["updated_at"]+ assert out["memories"][0]["kind"] == "chat"++ pages = []+ for offset in (0, 2, 4):+ page = await list_memories(+ client, user_id="u", scene="all", limit=2, offset=offset,+ )+ assert page["total"] == 6+ pages.extend(m["memory_id"] for m in page["memories"])+ assert pages == [m["memory_id"] for m in out["memories"]]++ with pytest.raises(ValueError, match="desc"):+ await list_memories(client, user_id="u", scene="all", order="asc")+ finally:+ await coding.close()+ await working.close()+++async def test_list_all_applies_source_and_status_filters(coding_config, mock_embed):+ coding, working, nodes = await _seed_all(coding_config, mock_embed)+ try:+ client = _client(coding_config, mock_embed,+ {"coding": coding, "working": working}, nodes=nodes)+ list_memories = _unwrapped("async_list_memories")++ out = await list_memories(+ client, user_id="u", scene="all", include_sources=["claude"],+ )+ assert [m["memory_id"] for m in out["memories"]] == [+ "m-newest", "w-mid", "c-old", "m-oldest",+ ]+ assert out["totals"] == {"chat": 2, "working": 1, "coding": 1}+ assert out["total"] == 4++ out = await list_memories(+ client, user_id="u", scene="all", statuses=["archived"],+ )+ # 经验只有 ACTIVE:两路生产力不贡献;chat 假库不按状态过滤,原样返回+ assert out["totals"]["working"] == 0 and out["totals"]["coding"] == 0+ assert all(m["scene"] == "chat" for m in out["memories"])+ finally:+ await coding.close()+ await working.close()+++async def test_list_all_does_not_create_unwritten_scene_databases(coding_config, mock_embed):+ client = _client(coding_config, mock_embed, {}, nodes=[+ _chat_node("m1", created=BASE),+ ])+ out = await _unwrapped("async_list_memories")(client, user_id="u", scene="all")+ assert out["total"] == 1+ assert out["totals"] == {"chat": 1, "working": 0, "coding": 0}+ for variant in ("working", "coding"):+ assert not CodingMemoryStore.database_exists(+ coding_config, db_path=coding_config.coding.db_path, variant=variant,+ )+++# ================================================================+# update / delete 生产力条目+# ================================================================++async def test_update_experience_replaces_solution_and_keeps_task(coding_config, mock_embed):+ working = await _store(coding_config, mock_embed, "working")+ try:+ await working.insert(CodingMemory(+ experience_id="e1", user_id="u", task="deploy service",+ search_keys=["rollout"], solution="old way",+ ))+ await _set_updated(working, "e1", BASE)+ client = _client(coding_config, mock_embed, {"working": working})++ out = await _unwrapped("async_update")(client, "e1", "new way")+ assert out["success"] is True+ assert out["memory_id"] == "e1"+ assert out["kind"] == "experience" and out["variant"] == "working"+ assert {"request_id", "elapsed_ms"} <= set(out)++ stored = await working.get_by_id("e1")+ assert stored.task == "deploy service"+ assert stored.solution == "new way"+ assert stored.updated_at > BASE+ # solution 不进向量:仍能按原 task 召回+ hits = await working.search_by_query_embedding(+ await mock_embed.embed("deploy service"), user_id="u",+ )+ assert hits and hits[0]["experience_id"] == "e1"++ out = await _unwrapped("async_update")(+ client, "e1", "newer way", task="ship service",+ )+ assert out["success"] is True+ stored = await working.get_by_id("e1")+ assert stored.task == "ship service"+ hits = await working.search_by_query_embedding(+ await mock_embed.embed("ship service"), user_id="u",+ )+ assert hits[0]["experience_id"] == "e1"+ assert hits[0]["score"] == pytest.approx(1.0, abs=1e-4)+ finally:+ await working.close()+++async def test_update_and_delete_fact(coding_config, mock_embed):+ coding = await _store(coding_config, mock_embed, "coding")+ try:+ await coding.insert_fact(WorkingFact(+ fact_id="f1", user_id="u", statement="build uses make",+ ))+ client = _client(coding_config, mock_embed, {"coding": coding})++ out = await _unwrapped("async_update")(+ client, "f1", "build uses bazel", kind="fact",+ )+ assert out["success"] is True and out["variant"] == "coding"+ assert (await coding.get_fact("f1")).statement == "build uses bazel"+ hits = await coding.search_facts(+ await mock_embed.embed("build uses bazel"), user_id="u",+ )+ assert [f.fact_id for f, _ in hits] == ["f1"]++ with pytest.raises(ValueError, match="task"):+ await _unwrapped("async_update")(client, "f1", "x", task="t")++ out = await _unwrapped("async_delete")(client, "f1")+ assert out["success"] is True and out["deleted_count"] == 1+ assert out["kind"] == "fact"+ assert await coding.get_fact("f1") is None+ assert await coding.search_facts(+ await mock_embed.embed("build uses bazel"), user_id="u",+ ) == []+ finally:+ await coding.close()+++async def test_delete_experience_removes_row_and_vectors(coding_config, mock_embed):+ working = await _store(coding_config, mock_embed, "working")+ try:+ await working.insert(CodingMemory(+ experience_id="e1", user_id="u", task="deploy service",+ search_keys=["rollout"], solution="S",+ ))+ client = _client(coding_config, mock_embed, {"working": working})++ out = await _unwrapped("async_delete")(+ client, "e1", kind="experience", variant="working",+ )+ assert out["success"] is True+ assert out["deleted_count"] == 1+ assert out["memory_id"] == "e1"+ assert await working.get_by_id("e1") is None+ assert await working._vec.get_by_id("e1:0") is None+ assert await working._vec.get_by_id("e1:1") is None+ finally:+ await working.close()+++async def test_productivity_not_found_and_ambiguity(coding_config, mock_embed):+ working = await _store(coding_config, mock_embed, "working")+ coding = await _store(coding_config, mock_embed, "coding")+ try:+ for store in (working, coding):+ await store.insert(CodingMemory(+ experience_id="same", user_id="u", task="T", solution="S",+ ))+ client = _client(coding_config, mock_embed,+ {"working": working, "coding": coding})++ with pytest.raises(AmbiguousMemoryIdError):+ await _unwrapped("async_update")(client, "same", "x")+ with pytest.raises(AmbiguousMemoryIdError):+ await _unwrapped("async_delete")(client, "same")++ out = await _unwrapped("async_delete")(client, "same", variant="coding")+ assert out["success"] is True and out["variant"] == "coding"+ assert await working.get_by_id("same") is not None++ missing = await _unwrapped("async_update")(client, "nope", "x", kind="experience")+ assert missing["success"] is False and "not found" in missing["error_message"]+ missing = await _unwrapped("async_delete")(client, "nope", kind="fact")+ assert missing["success"] is False and missing["deleted_count"] == 0+ # variant 给了就不回落到 chat+ missing = await _unwrapped("async_delete")(client, "nope", variant="working")+ assert missing["success"] is False and missing["deleted_count"] == 0++ with pytest.raises(ValueError):+ await _unwrapped("async_delete")(client, "same", kind="chat", variant="coding")+ finally:+ await working.close()+ await coding.close()+++async def test_update_and_delete_without_kind_still_handle_chat(coding_config, mock_embed):+ """默认行为不变:chat ID 走原 chat 路径(store 都没建时也不建库)。"""+ client = _client(coding_config, mock_embed, {})+ seen = []++ async def _chat_update(memory_id, content):+ seen.append(("update", memory_id, content))+ return {"success": True, "memory_id": memory_id}++ async def _chat_delete(memory_id):+ seen.append(("delete", memory_id))+ return {"success": True, "deleted_count": 1}++ client._update_chat = _chat_update+ client._delete_chat = _chat_delete+ client._vector_store = _FakeVectorStore([_chat_node("m1", created=BASE)])++ assert (await _unwrapped("async_update")(client, "m1", "new"))["success"]+ assert (await _unwrapped("async_delete")(client, "m1"))["success"]+ # 哪都没有:仍交给 chat 路径给出原来的 not-found 结果+ await _unwrapped("async_delete")(client, "ghost")+ assert seen == [("update", "m1", "new"), ("delete", "m1"), ("delete", "ghost")]+ for variant in ("working", "coding"):+ assert not CodingMemoryStore.database_exists(+ coding_config, db_path=coding_config.coding.db_path, variant=variant,+ )diff --git a/tests/coding/test_list_and_stats_by_scene.py b/tests/coding/test_list_and_stats_by_scene.pyindex e05d4d9..5511ab7 100644--- a/tests/coding/test_list_and_stats_by_scene.py+++ b/tests/coding/test_list_and_stats_by_scene.py@@ -6,7 +6,7 @@ working 两类经验既列不出也数不到:一个 45 条记忆的库在界"""import asyncio-from datetime import datetime, timedelta+from datetime import datetime, timedelta, timezonefrom types import SimpleNamespaceimport pytest@@ -97,13 +97,14 @@ async def test_stats_counts_every_scene_with_its_latest_times(coding_config, moc"latest_updated_at": int((BASE + timedelta(days=1)).timestamp()),}assert stats["scenes"]["coding"]["count"] == 2+ # Productivity stores write naive UTC (utcnow), so naive means UTC.assert stats["scenes"]["coding"]["latest_created_at"] == int(- (BASE + timedelta(hours=2)).timestamp()+ (BASE + timedelta(hours=2)).replace(tzinfo=timezone.utc).timestamp())# The store stamps updated_at on write; the stat is the newest it holds.stored = [await coding.get_by_id(eid, user_id="u") for eid in ("c1", "c2")]assert stats["scenes"]["coding"]["latest_updated_at"] == max(- int(item.updated_at.timestamp()) for item in stored+ int(item.updated_at.replace(tzinfo=timezone.utc).timestamp()) for item in stored)assert stats["scenes"]["working"]["count"] == 1assert stats["scenes"]["working"]["facts"] == 1diff --git a/tests/test_search_rerank_mmr_gates.py b/tests/test_search_rerank_mmr_gates.pynew file mode 100644index 0000000..aca395e--- /dev/null+++ b/tests/test_search_rerank_mmr_gates.py@@ -0,0 +1,258 @@+# -*- coding: utf-8 -*-+"""search(rerank=...) 与 MMR 的按次开关。++- rerank=False:本地 cross-encoder 与图重排都不跑(看 spy 是否被调到)。+- MMR:调用方的 limit < MMR_MAX_TOP_K 时启用,>= 时跳过。+- 默认值(rerank=True、limit=10)保持原行为。+"""++import asyncio+import math+import uuid++import pytest++from hy_memory.config import MemoryConfig+from hy_memory.models.memory import MemoryLayer, MemoryNode, MemoryStatus+from hy_memory.pipelines import reader_base+from hy_memory.pipelines._retrieval.diversity import MMR_MAX_TOP_K, mmr_applies+from hy_memory.pipelines.base import ReadRequest++DIMS = 32+++def _unit(vec):+ n = sum(x * x for x in vec) ** 0.5 or 1.0+ return [x / n for x in vec]+++def _query_vec():+ return _unit([1.0] + [0.0] * (DIMS - 1))+++def _vec(cos):+ return _unit([cos, math.sqrt(1 - cos * cos)] + [0.0] * (DIMS - 2))+++def config(tmp_path):+ return MemoryConfig.from_dict({"vector_store": {+ "provider": "chroma",+ "collection_name": f"t_gates_{uuid.uuid4().hex[:8]}",+ "persist_directory": str(tmp_path / "chroma"),+ "embedding_dims": DIMS,+ }})+++async def _reader_with(config, count):+ from hy_memory.data.vector_store_chroma import ChromaVectorStore+ from hy_memory.pipelines.reader_legacy import LegacyReadPipeline++ store = ChromaVectorStore(config)+ await store.initialize()+ for index in range(count):+ node = MemoryNode(+ node_id=f"m{index:02d}", user_id="u1", agent_id="a1", session_id="s1",+ content=f"memory number {index} about topic{index} and detail{index}",+ layer=MemoryLayer.L2_FACT, status=MemoryStatus.ACTIVE, is_latest=True,+ )+ node.embedding = _vec(0.95 - index * 0.01)+ await store.upsert(node)+ reader = LegacyReadPipeline(config, vector_store=store)+ await reader.initialize()+ return reader, store+++def _request(limit, **kw):+ return ReadRequest(+ query="memory topic", query_embedding=_query_vec(),+ user_ids=["u1"], agent_ids=["a1"],+ limit=limit, min_score=0.2, schema_min_score=0.2, **kw,+ )+++def mmr_spy(monkeypatch):+ calls = []+ real = reader_base.mmr_select++ def _spy(hits, limit, **kw):+ calls.append(limit)+ return real(hits, limit, **kw)++ monkeypatch.setattr(reader_base, "mmr_select", _spy)+ return calls+++def test_mmr_threshold_is_defined_once():+ assert MMR_MAX_TOP_K == 20+ assert mmr_applies(19, 0.55)+ assert not mmr_applies(20, 0.55)+ # 权重仍由 MMR_LAMBDA 控制:关掉 λ 时任何 top-k 都不走 MMR+ assert not mmr_applies(5, 0.0)+ assert not mmr_applies(5, 1.0)+++def test_mmr_runs_when_limit_below_threshold(config, mmr_spy):+ async def _run():+ reader, store = await _reader_with(config, 12)+ try:+ resp = await reader.read(_request(5))+ assert resp.success+ assert resp.extra["config"]["mmr_applied"] is True+ assert len(resp.memories) == 5+ finally:+ await store.close()++ asyncio.run(_run())+ assert mmr_spy == [5]+++def test_mmr_skipped_when_limit_reaches_threshold(config, mmr_spy):+ async def _run():+ reader, store = await _reader_with(config, MMR_MAX_TOP_K + 6)+ try:+ resp = await reader.read(_request(MMR_MAX_TOP_K))+ assert resp.success+ assert resp.extra["config"]["mmr_applied"] is False+ ids = [m["memory_id"] for m in resp.memories]+ assert len(ids) == MMR_MAX_TOP_K+ # 无 MMR:按召回分(构造时单调递减)原序截断+ assert ids == [f"m{index:02d}" for index in range(MMR_MAX_TOP_K)]+ finally:+ await store.close()++ asyncio.run(_run())+ assert mmr_spy == []+++class _FakeReranker:+ model_name = "fake-cross-encoder"+ device = "cpu"+ load_error = ""++ def __init__(self):+ self.calls = 0++ def score(self, query, documents):+ self.calls += 1+ # 反转召回序:分数与原名次相反+ return [float(i) for i in range(len(documents))]+++def rerank_spies(config, monkeypatch):+ config.recall.local_rerank_enabled = True+ reranker = _FakeReranker()+ factory_calls = []++ def _get_local_reranker(*args, **kwargs):+ factory_calls.append(kwargs)+ return reranker++ monkeypatch.setattr(reader_base, "get_local_reranker", _get_local_reranker)+ graph_calls = []++ async def _graph_rerank(self, *, hits, **kwargs):+ graph_calls.append(len(hits))+ return hits, [], {}++ monkeypatch.setattr(+ reader_base.BaseReadPipeline, "_apply_graph_rerank", _graph_rerank,+ )+ monkeypatch.setattr(+ reader_base.BaseReadPipeline, "_expansion_on", lambda self: True,+ )+ return {"reranker": reranker, "factory": factory_calls, "graph": graph_calls}+++def test_rerank_false_skips_local_and_graph_rerank(config, rerank_spies):+ async def _run():+ reader, store = await _reader_with(config, 8)+ try:+ resp = await reader.read(_request(5, rerank=False))+ assert resp.success+ assert resp.extra["config"]["rerank"] is False+ assert resp.extra["config"]["local_rerank_enabled"] is False+ assert resp.extra["local_rerank"]["applied"] is False+ return [m["memory_id"] for m in resp.memories]+ finally:+ await store.close()++ ids = asyncio.run(_run())+ assert rerank_spies["factory"] == []+ assert rerank_spies["reranker"].calls == 0+ assert rerank_spies["graph"] == []+ assert len(ids) == 5+++def test_rerank_default_true_keeps_rerank_stages(config, rerank_spies):+ async def _run():+ reader, store = await _reader_with(config, 8)+ try:+ req = _request(5)+ assert req.rerank is True+ resp = await reader.read(req)+ assert resp.success+ assert resp.extra["config"]["rerank"] is True+ finally:+ await store.close()++ asyncio.run(_run())+ assert len(rerank_spies["factory"]) == 1+ assert rerank_spies["reranker"].calls >= 1+ assert len(rerank_spies["graph"]) == 1+++def test_rerank_is_per_request_under_concurrency(config, rerank_spies):+ """并发的两次 read 各按自己的 rerank 走,不互相影响。"""+ async def _run():+ reader, store = await _reader_with(config, 8)+ try:+ off, on = await asyncio.gather(+ reader.read(_request(5, rerank=False)),+ reader.read(_request(5, rerank=True)),+ )+ assert off.extra["config"]["rerank"] is False+ assert on.extra["config"]["rerank"] is True+ assert off.extra["local_rerank"]["applied"] is False+ finally:+ await store.close()++ asyncio.run(_run())+ assert len(rerank_spies["factory"]) == 1+ assert len(rerank_spies["graph"]) == 1++[email protected]("kwargs, expected", [({}, True), ({"rerank": False}, False)])+def test_client_search_threads_rerank_into_read_request(kwargs, expected):+ """client.async_search → ReadRequest.rerank;默认 True(原行为)。"""+ from hy_memory.client import HyMemoryClient+ from hy_memory.pipelines.base import ReadResponse++ seen = {}++ class _Reader:+ VERSION = "fake"++ async def read(self, request):+ seen["rerank"] = request.rerank+ seen["limit"] = request.limit+ return ReadResponse()++ class _Registry:+ async def get_reader(self, reader_name=""):+ return _Reader()++ client = object.__new__(HyMemoryClient)+ client._config = MemoryConfig.from_env()+ client._cache = None+ client._history_store = None+ client._registry = _Registry()+ client._mode = "pro"++ out = asyncio.run(HyMemoryClient.async_search.__wrapped__(+ client, "q", user_ids=["u"], limit=7, **kwargs,+ ))+ assert "memories" in out+ assert seen == {"rerank": expected, "limit": 7}diff --git a/tests/test_server_memory_namespace.py b/tests/test_server_memory_namespace.pynew file mode 100644index 0000000..4dd2ce5--- /dev/null+++ b/tests/test_server_memory_namespace.py@@ -0,0 +1,103 @@+"""The memory routes report an ambiguous id as 409 and pass kind/variant on.++An id can exist in more than one namespace (chat, experience, fact). The+client fails closed with AmbiguousMemoryIdError; over HTTP that was a 500.+"""++import json+import threading+from http.server import ThreadingHTTPServer+from urllib.request import Request, urlopen+from urllib.error import HTTPError++import pytest++from hy_memory import server+from hy_memory.retrieval import AmbiguousMemoryIdError+++class _Client:+ def __init__(self):+ self.calls = []++ def get(self, memory_id, **kwargs):+ self.calls.append(("get", memory_id, kwargs))+ if not kwargs:+ raise AmbiguousMemoryIdError(memory_id, ("chat", "working/experience"))+ return {"memory_id": memory_id}++ def update(self, memory_id, content, **kwargs):+ self.calls.append(("update", memory_id, kwargs))+ return {"success": True, "memory_id": memory_id}++ def delete(self, memory_id, **kwargs):+ self.calls.append(("delete", memory_id, kwargs))+ if kwargs.get("kind") == "bogus":+ raise ValueError("kind must be one of: chat, experience, fact")+ return {"success": True, "deleted_count": 1}+++def running(monkeypatch):+ client = _Client()+ monkeypatch.setattr(server, "_get_client", lambda: client)+ httpd = ThreadingHTTPServer(("127.0.0.1", 0), server.MemoryHTTPHandler)+ thread = threading.Thread(target=httpd.serve_forever, daemon=True)+ thread.start()+ try:+ yield client, f"http://127.0.0.1:{httpd.server_address[1]}"+ finally:+ httpd.shutdown()+ httpd.server_close()+++def _call(method, url, body=None):+ data = json.dumps(body).encode() if body is not None else None+ request = Request(url, data=data, method=method, headers={"Content-Type": "application/json"})+ try:+ with urlopen(request) as response:+ return response.status, json.loads(response.read())+ except HTTPError as error:+ return error.code, json.loads(error.read())+++def test_an_ambiguous_id_is_409_not_500(running):+ _, base = running++ status, body = _call("GET", f"{base}/api/v1/memories/m1")++ assert status == 409+ assert body["error"] == "ambiguous_memory_id"+++def test_kind_and_variant_disambiguate_get_update_and_delete(running):+ client, base = running++ assert _call("GET", f"{base}/api/v1/memories/m1?kind=experience&variant=coding")[0] == 200+ assert _call(+ "PUT", f"{base}/api/v1/memories/m1",+ {"content": "new", "kind": "experience", "variant": "working", "task": "T"},+ )[0] == 200+ assert _call("DELETE", f"{base}/api/v1/memories/m1?kind=fact&variant=coding")[0] == 200++ assert client.calls == [+ ("get", "m1", {"kind": "experience", "variant": "coding"}),+ ("update", "m1", {"kind": "experience", "variant": "working", "task": "T"}),+ ("delete", "m1", {"kind": "fact", "variant": "coding"}),+ ]+++def test_a_bad_namespace_is_400(running):+ _, base = running++ status, _ = _call("DELETE", f"{base}/api/v1/memories/m1?kind=bogus")++ assert status == 400+++def test_chat_calls_without_a_namespace_are_unchanged(running):+ client, base = running++ _call("PUT", f"{base}/api/v1/memories/m1", {"content": "new"})++ assert client.calls == [("update", "m1", {})]