fix(memhub): the embedding endpoint no longer follows the generation base_url

A remote embedding with no `embedding_base_url` resolved to the generation
`base_url` at runtime (`build_sdk_config`, `vector_collection_bases`, the
probe). The collection name hashes that endpoint, so a proxy or region edit
of the generation endpoint moved writes to a new, empty collection, and
providers without embeddings were sent embedding requests.

- `resolve_embedding_endpoint` no longer inherits; creating or updating a
  remote (non-local_onnx) embedding without an endpoint is refused with
  422 `embedding_base_url_required`. The runtime and probe read only
  `embedding_base_url`. The API key stays shared.
- Opening the profile store pins, once and idempotently, every stored
  remote embedding left without an endpoint to the one it resolved to
  (the generation base_url, or the provider default), so the collection
  name is byte-identical. `read_active_profile` applies the same rule for
  `sdk-migrate`, which may run before Core has opened the store.
- Web: settings write the prefilled endpoint instead of relying on the
  fallback; onboarding writes an empty custom field as the endpoint it
  means. CLI headless configs now get the 422 code.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

CHANGELOG.md

@@ -4,6 +4,24 @@ Hy Memory and MemHub are versioned and released independently.
 
 ## Unreleased
 
+## MemHub 1.0.5 — 2026-10-28
+
+Build 36, on `hy-memory==2.0.8`. Linux x64/arm64 Runtime and macOS arm64
+App and Runtime. Upgrading from 1.0.4 migrates the existing library to SDK
+authority on first launch.
+
+- MemHub turns off the HY pipeline log and trace at every diagnostic level
+  (hy-memory 2.0.8 `MEMORY_PIPELINE_LOG_ENABLED=false`,
+  `MEMORY_PIPELINE_TRACE_ENABLED=false`), so the per-step JSONL files under
+  `hy-memory/governed-v2/logs/` and the `pipeline_logs` rows stop growing.
+  The Debug panel no longer shows the HY pipeline section. Existing files are
+  left in place.
+- HY SDK text logs are written once, to `hy_memory.log`. They are no longer
+  copied to `service.log` and `service-error.log` through the SDK's
+  stdout/stderr streams. SDK warnings and errors also go to `core.log`, so the
+  Debug panel still shows them. A live switch of the diagnostic level now also
+  changes the level of `hy_memory.log`.
+
 - MemHub shows when working and coding experiences were talked about. After
   the SDK upgrade every one of them read "时间未知" (time unknown) because the
   SDK never stored their conversation time; hy-memory 2.0.7 stores it and
@@ -76,8 +94,33 @@ Hy Memory and MemHub are versioned and released independently.
   `hy_node_permissions` proof table. Evidence, governed memories, model
   profiles, SDK stores, and source/host grants are preserved.
 
+## Hy Memory 2.0.9 — 2026-11-01
+
+- Published
+  [`hy-memory==2.0.9`](https://pypi.org/project/hy-memory/2.0.9/).
+- Placeholder values no longer overwrite the user's basic profile (L0). A
+  small extraction model filled `basic_info` with `{"name": "用户"}`,
+  `The user` or `N/A` when the user had said nothing about themselves, and
+  each placeholder superseded the real value, so the L0 chain read
+  费天翔 → Fei → 用户 → The user. Two defences:
+  - `upsert_basic_profile` drops placeholder values: empty, `用户`,
+    `the user`, `user`, `n/a`, `na`, `none`, `null`, `unknown`, `未提供`,
+    `未知`, `不详`, `-`, `?` and the field's own name, compared
+    case-insensitively with whitespace and punctuation stripped. When nothing
+    is left it writes no new version and no new L0 head. Placeholders already
+    stored in the chain no longer override earlier real values when the
+    profile is assembled, so `get_user_profile` of an affected user shows the
+    last real value again without any migration. This also stops an
+    assistant quoting an old memory ("The user's name is 用户.") from being
+    written back.
+  - The extraction prompts (zh and en) state the rule: only what the user
+    said in a `user` turn, never the field name or a placeholder, `{}`
+    otherwise, with a small-talk counter-example.
+
 ## Hy Memory 2.0.8 — 2026-10-28
 
+- Published
+  [`hy-memory==2.0.8`](https://pypi.org/project/hy-memory/2.0.8/).
 - New `MEMORY_PIPELINE_LOG_ENABLED` (default `true`) turns the pipeline JSONL
   log (`{MEMORY_LOG_DIR}/<subdir>/<date>.log`) off. With `false` no JSONL
   file or directory is written. When `MEMORY_PIPELINE_TRACE_ENABLED` is also

README.md

@@ -33,6 +33,7 @@ English | [中文](README.zh.md)
 ## Latest News
 
 * *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 🚀 **Open-sourced** quantized **FP8** (**[Hy-Memory-30B-A3B-FP8](https://huggingface.co/tencent/Hy-Memory-30B-A3B-FP8)**) and **GGUF** (**[Hy-Memory-30B-A3B-GGUF](https://huggingface.co/tencent/Hy-Memory-30B-A3B-GGUF)**) versions of **Hy-Memory-30B-A3B** on Hugging Face!
+* *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 📦 **Released [MemHub v1.0.5](https://github.com/Tencent-Hunyuan/Hy-Memory/releases/tag/v1.0.5)** with Chinese, English and Spanish interfaces, one-time pairing codes for more custom Harnesses, and smoother browsing, search, startup and recovery, on **`hy-memory==2.0.8`**. See the release notes for details.
 * *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 📦 **Released [MemHub v1.0.4](https://github.com/Tencent-Hunyuan/Hy-Memory/releases/tag/v1.0.4)** and **[memhub-cli 1.0.5](https://www.npmjs.com/package/memhub-cli/v/1.0.5)**, with a signed macOS desktop app and verified macOS/Linux Runtimes!
 * *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 🚀 **Released** **Hy Memory 2.0 (`hy-memory==2.0.4`)** on [PyPI](https://pypi.org/project/hy-memory/2.0.4/) and open-sourced the **Hy-Memory** monorepo together with **[MemHub](memhub/README.md)**!
 * *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 🚀 **Open-sourced** **[Hy-Memory-30B-A3B](https://huggingface.co/tencent/Hy-Memory-30B-A3B)** on Hugging Face along with its [technical report](https://arxiv.org/abs/2610.22196) on attributed reinforcement learning for long-term memory writing!

README.zh.md

@@ -33,6 +33,7 @@
 ## 最新动态
 
 * *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 🚀 **模型开源** 在 Hugging Face 发布 **Hy-Memory-30B-A3B** 的 **FP8**（**[Hy-Memory-30B-A3B-FP8](https://huggingface.co/tencent/Hy-Memory-30B-A3B-FP8)**）与 **GGUF**（**[Hy-Memory-30B-A3B-GGUF](https://huggingface.co/tencent/Hy-Memory-30B-A3B-GGUF)**）量化版本模型！
+* *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 📦 **正式发布 [MemHub v1.0.5](https://github.com/Tencent-Hunyuan/Hy-Memory/releases/tag/v1.0.5)**：支持中文、英文和西班牙语界面，可通过一次性配对码连接更多自定义 Harness，并优化了记忆浏览、搜索、启动和异常恢复；底层使用 **`hy-memory==2.0.8`**。详见发布说明。
 * *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 📦 **正式发布 [MemHub v1.0.4](https://github.com/Tencent-Hunyuan/Hy-Memory/releases/tag/v1.0.4)** 与 **[memhub-cli 1.0.5](https://www.npmjs.com/package/memhub-cli/v/1.0.5)**，提供已签名的 macOS 桌面应用及经过验证的 macOS/Linux Runtime！
 * *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 🚀 **正式发布** **Hy Memory 2.0 (`hy-memory==2.0.4`)**（已上线 [PyPI](https://pypi.org/project/hy-memory/2.0.4/)），并开源 **Hy-Memory** monorepo 与 **[MemHub](memhub/README.md)**！
 * *<mark>[new]</mark>* 🔥🔥🔥 **[2026-10]**: 🚀 **模型开源** 在 Hugging Face 发布 **[Hy-Memory-30B-A3B](https://huggingface.co/tencent/Hy-Memory-30B-A3B)** 长期记忆写入模型及[技术报告](https://arxiv.org/abs/2610.22196)！

hy_memory/agent/extractor.py

@@ -682,6 +682,23 @@ Output:
 ```
 John's occupation and location are HIS attributes, so they go into `memory` with "John" as the subject. They must NEVER land in `basic_info.occupation` / `basic_info.location` — `basic_info` is exclusively the user's own profile. Only `name` (Tim, from the user message's `name` field) belongs there.
 
+## Example 11 — Counter-example: small talk has no basic_info
+
+New Messages:
+[{"role": "user", "content": "Hi"},
+ {"role": "assistant", "content": "Hello! The user's name is The user. How can I help?"}]
+Memory Date: 2025-09-03
+
+Output:
+```json
+{
+  "memory": [],
+  "intentions": [],
+  "basic_info": {}
+}
+```
+The user stated nothing about themselves. The assistant's line is not a user turn, and "The user" is a placeholder, not a name. Output `{}` — never `{"name": "The user"}` or `{"name": "user"}`.
+
 ---
 """
 
@@ -749,6 +766,14 @@ Rules:
   fields (e.g. name, age, location, occupation, employer) **explicitly stated**
   in the NEW user messages. Never infer, never invent. If no field is explicitly
   stated, output `{{}}`.
+  * HARD RULE: fill a field ONLY if the user stated it in a `user` turn.
+    Anything said only by the assistant (including the assistant quoting an
+    earlier memory such as "The user's name is X") does NOT count. If nothing
+    qualifies, output `"basic_info": {{}}`.
+  * NEVER write the field name itself or a placeholder as a value ("user",
+    "The user", "用户", "name", "N/A", "unknown", "none", "-"). Omit the field.
+  * Negative example: small talk such as `[user]: Hi` / `[assistant]: How can
+    I help?`, or `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
   * Exception for `name`: the `name` field on the user's own message, or a leading
     line "The user's name is X" / "用户名叫X", is an authoritative source for
     `name` — even though the user never said it out loud.
@@ -817,6 +842,14 @@ Rules:
   fields (e.g. name, age, location, occupation, employer) **explicitly stated**
   in the NEW user messages. Never infer, never invent. If no field is explicitly
   stated, output `{{}}`.
+  * HARD RULE: fill a field ONLY if the user stated it in a `user` turn.
+    Anything said only by the assistant (including the assistant quoting an
+    earlier memory such as "The user's name is X") does NOT count. If nothing
+    qualifies, output `"basic_info": {{}}`.
+  * NEVER write the field name itself or a placeholder as a value ("user",
+    "The user", "用户", "name", "N/A", "unknown", "none", "-"). Omit the field.
+  * Negative example: small talk such as `[user]: Hi` / `[assistant]: How can
+    I help?`, or `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`.
   * Exception for `name`: the `name` field on the user's own message, or a leading
     line "The user's name is X" / "用户名叫X", is an authoritative source for
     `name` — even though the user never said it out loud.

hy_memory/agent/prompts_zh.py

@@ -365,6 +365,13 @@ EXTRACT_PROMPT_ZH = """## 最近 k 条消息
 * basic_info：**只装用户本人的画像**。
   仅当 NEW user messages 中**明确**陈述稳定画像字段（如 姓名、年龄、所在地、职业、雇主）时才填写。
   绝不推断、绝不编造。没有任何字段被明确陈述时输出 `{{}}`。
+  * **硬性规则**：只有用户在 `user` 回合里**明确说出**的字段才能填写。只在
+    assistant 回合出现的内容（包括 assistant 引用旧记忆，如"The user's name is X"
+    / "用户名是X"）一律不算。没有符合条件的字段时，必须输出 `"basic_info": {{}}`。
+  * **绝不**把字段名本身或占位符当值写入（"用户"、"The user"、"user"、"name"、
+    "姓名"、"N/A"、"unknown"、"未知"、"未提供"、"-"），宁可省略该字段。
+  * 负例：寒暄如 `[user]: 你好` / `[assistant]: 我可以帮你。`，或
+    `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
   * `name` 的例外：用户自己那条消息上的 `name` 字段，或文首形如
     "用户名叫X" / "The user's name is X" 的那一行，都是 `name` 的权威来源
     ——即使用户本人从未开口自报姓名。
@@ -440,6 +447,13 @@ EXTRACT_PROMPT_ZH_NO_INTENTION = """## 最近 k 条消息
 * basic_info：**只装用户本人的画像**。
   仅当 NEW user messages 中**明确**陈述稳定画像字段（如 姓名、年龄、所在地、职业、雇主）时才填写。
   绝不推断、绝不编造。没有任何字段被明确陈述时输出 `{{}}`。
+  * **硬性规则**：只有用户在 `user` 回合里**明确说出**的字段才能填写。只在
+    assistant 回合出现的内容（包括 assistant 引用旧记忆，如"The user's name is X"
+    / "用户名是X"）一律不算。没有符合条件的字段时，必须输出 `"basic_info": {{}}`。
+  * **绝不**把字段名本身或占位符当值写入（"用户"、"The user"、"user"、"name"、
+    "姓名"、"N/A"、"unknown"、"未知"、"未提供"、"-"），宁可省略该字段。
+  * 负例：寒暄如 `[user]: 你好` / `[assistant]: 我可以帮你。`，或
+    `[user]: Reply with exactly: PONG` → `"basic_info": {{}}`。
   * `name` 的例外：用户自己那条消息上的 `name` 字段，或文首形如
     "用户名叫X" / "The user's name is X" 的那一行，都是 `name` 的权威来源
     ——即使用户本人从未开口自报姓名。
@@ -669,6 +683,23 @@ Memory Date：2025-09-02
 ```
 职业和所在地是 **John 的**属性，所以进 `memory` 并以"John"作主体，**绝不能**落到 `basic_info` 的 `occupation` / `location` —— `basic_info` 专属于用户本人。只有 `name`（Tim，来自用户消息的 `name` 字段）才该放进去。注意输出语言随输入语言（此例为英文）。
 
+## 示例 11 —— 反例：寒暄没有 basic_info
+
+新消息：
+[{"role": "user", "content": "你好"},
+ {"role": "assistant", "content": "你好！我可以帮你。之前记得 The user's name is 用户."}]
+Memory Date：2025-09-03
+
+输出：
+```json
+{
+  "memory": [],
+  "intentions": [],
+  "basic_info": {}
+}
+```
+用户没有说任何关于自己的信息。assistant 那句不是 user 回合，"用户" 也是占位符而不是名字。必须输出 `{}`——**绝不能**输出 `{"name": "用户"}`。
+
 ---
 """
 

hy_memory/agent/tools/basic_profile.py

@@ -26,6 +26,8 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import re
+import unicodedata
 import uuid
 import weakref
 from dataclasses import dataclass
@@ -208,6 +210,76 @@ def _sanitize_kv(
     return result
 
 
+# ================================================================
+# 占位符守卫（P0-1）
+# ================================================================
+# 弱模型（如 qwen3.5-2b）在用户什么都没说时，会把 schema 字段说明里的词当值
+# 填进 basic_info：{"name": "用户"} / "The user" / "N/A"。每个占位符都会
+# supersede 掉真实值，演化链变成 费天翔 → Fei → 用户 → The user。
+# 规则：占位符永远不入库；读侧组装 KV 时占位符也不覆盖已有真实值。
+
+_PLACEHOLDER_VALUES = frozenset({
+    "用户", "该用户", "本用户", "用户本人",
+    "the user", "the user's", "user", "a user", "this user",
+    "n/a", "na", "none", "null", "nil", "unknown", "unspecified",
+    "not provided", "not specified", "not mentioned",
+    "未提供", "未知", "不详", "未说明", "未提及", "无",
+    "-", "?",
+})
+
+# 内置字段的中文标签：弱模型也会把字段说明的中文词当值。
+_FIELD_LABELS: Dict[str, tuple] = {
+    "name": ("姓名", "名字", "用户名", "用户姓名", "用户名字"),
+    "age": ("年龄", "用户年龄"),
+    "location": ("所在地", "地点", "城市", "用户所在地"),
+    "occupation": ("职业", "工作", "用户职业"),
+    "employer": ("雇主", "公司", "用户雇主"),
+}
+
+# 去掉标点/符号后再比较，让 "The user." / "用户。" / "N/A" 都命中。
+# "-" / "?" 本身就是纯标点，剥完为空串，同样判为占位符。
+_PUNCT_RE = re.compile(r"[\s\.,;:!?'\"`~()\[\]{}<>/\\|_\-\u3000-\u303f\uff00-\uff0f\uff1a-\uff20]+")
+
+
+def _placeholder_key(value: str) -> str:
+    s = unicodedata.normalize("NFKC", str(value or "")).strip().lower()
+    s = s.replace("\u2019", "'")
+    s = _PUNCT_RE.sub(" ", s)
+    return " ".join(s.split())
+
+
+_PLACEHOLDER_KEYS = frozenset(_placeholder_key(v) for v in _PLACEHOLDER_VALUES)
+
+
+def is_placeholder_value(field_name: str, value: Any) -> bool:
+    """value 是否为占位符（空 / 用户 / The user / N/A / 字段名本身 等）。
+
+    大小写不敏感、首尾空白与标点不敏感。数字（如 age=30）永远不是占位符。
+    """
+    if value is None:
+        return True
+    if isinstance(value, bool):
+        return False
+    if isinstance(value, (int, float)):
+        return False
+    key = _placeholder_key(value)
+    if not key:
+        return True
+    if key in _PLACEHOLDER_KEYS:
+        return True
+    field_key = _placeholder_key(field_name)
+    if field_key and key in (field_key, field_key.replace("_", " ")):
+        return True
+    for label in _FIELD_LABELS.get(field_name, ()):
+        if key == _placeholder_key(label):
+            return True
+    return False
+
+
+def _drop_placeholders(kv: Dict[str, Any]) -> Dict[str, Any]:
+    return {k: v for k, v in kv.items() if not is_placeholder_value(k, v)}
+
+
 # ================================================================
 # 公共入口：upsert_basic_profile
 # ================================================================
@@ -287,6 +359,8 @@ async def _upsert_basic_profile_unlocked(
     # L0 Basic Info 从输入、唯一性到落盘都只属于 user_id。
 
     new_kv = _sanitize_kv(kv or {}, allowed_fields=allowed_fields)
+    # 单调性守卫：占位符永远不覆盖已有值，过滤后为空就不写新版本、不产生新链头。
+    new_kv = _drop_placeholders(new_kv)
     if not new_kv:
         return BasicProfileUpsertResult(
             success=True, changed=False, reason="no valid fields after sanitize"
@@ -513,5 +587,8 @@ def _assemble_full_kv_from_nodes(
         for k, v in kv.items():
             if allowed_set is not None and k not in allowed_set:
                 continue
+            # 历史上已落盘的占位符版本（如 name=用户）不覆盖更早的真实值。
+            if is_placeholder_value(k, v):
+                continue
             full_kv[k] = v
     return full_kv

memhub/PRIVACY.md

@@ -29,10 +29,12 @@ prompt/response、密钥、访问令牌或完整本地路径。结构化日志
 文件。详细合同见
 [`docs/contracts/diagnostic-logging.md`](docs/contracts/diagnostic-logging.md)。
 
-用户显式把诊断级别切换为 `debug` 时，Core 会启用 HY pipeline trace，并将
-`MEMORY_LOG_LLM_CONTENT` 设为 `true`。该模式会把完整模型 prompt/response 写入本地调试
-日志，其中可能包含获授权的对话正文和模型输出；它只应用于有意识的故障排查，不应长期
-开启，也不应在未经检查和脱敏时分享相关日志。切回 `info` 会停止后续正文记录，但不会
+HY pipeline 日志与 trace 在任何级别下都关闭。HY SDK 的文本日志只写入
+`hy-memory/governed-v2/logs/hy_memory.log`，其中的 WARNING 及以上同时写入 `core.log`；
+SDK 不在 INFO 及以上级别记录对话或记忆正文。用户显式把诊断级别切换为 `debug` 时，Core 将
+`MEMORY_LOG_LLM_CONTENT` 设为 `true`。该模式会把完整模型 prompt/response 写入
+`hy_memory.log` 的 DEBUG 行，其中可能包含获授权的对话正文和模型输出；它只应用于有意识的
+故障排查，不应长期开启，也不应在未经检查和脱敏时分享相关日志。切回 `info` 会停止后续正文记录，但不会
 自动删除此前已写入的调试文件。
 
 具体行为以当前源码、网络请求实现和发布说明为准。发现实现与本说明不一致时，请按

memhub/README.md

@@ -18,13 +18,13 @@ If you run into a problem, please open an Issue with the version, platform,repro
 
 ## 发行与平台合同
 
-源码当前固定使用公开 PyPI 正式版 `hy-memory==2.0.7`。MemHub 源码版本为 `1.0.5`
-（build 14），GitHub 仓库为
+源码当前固定使用公开 PyPI 正式版 `hy-memory==2.0.9`。MemHub 源码版本为 `1.0.5`
+（build 36），GitHub 仓库为
 [`Tencent-Hunyuan/Hy-Memory`](https://github.com/Tencent-Hunyuan/Hy-Memory)，npm 包名为
 `memhub-cli`。当前代码架构见
 [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md)。
 
-`v1.0.5` 的发行目标是 Linux x64/arm64 Runtime 与 macOS arm64/x64 App 和 Runtime。
+`v1.0.5` 的发行目标是 Linux x64/arm64 Runtime 与 macOS arm64 App 和 Runtime。
 Linux 制品由 GitHub Actions 在原生架构 runner 上构建并完成生命周期验收；macOS
 制品由发行流水线完成 Developer ID 签名、公证和验收后手动上传。Windows 不支持。
 只有同时出现在 GitHub Release 与 `release-manifest.json` 中、且通过公开校验的制品才属于
@@ -118,7 +118,7 @@ MemHub 的 SQLite 数据默认位于 `~/.one-memory`，不在 npm 包或 Runtime
 
 ## Hy Memory
 
-SDK 依赖固定为公开 PyPI 正式版 `hy-memory==2.0.7`。SDK 配置、权限边界及 search
+SDK 依赖固定为公开 PyPI 正式版 `hy-memory==2.0.9`。SDK 配置、权限边界及 search
 返回格式见 [`MEMORY.md`](MEMORY.md)。HY search 返回的 `content` 已包含 SDK 统一生成的
 逻辑时间和演化上下文；调用方不应再次转换时间戳或重复拼接 `When`。
 

memhub/SBOM.spdx.json

@@ -2352,7 +2352,7 @@
     {
       "SPDXID": "SPDXRef-Package-hy-memory",
       "name": "hy-memory",
-      "versionInfo": "2.0.7",
+      "versionInfo": "2.0.9",
       "downloadLocation": "NOASSERTION",
       "filesAnalyzed": false,
       "licenseConcluded": "Apache-2.0",

memhub/THIRD_PARTY_NOTICES.md

@@ -9,7 +9,7 @@ Per-package license texts are not reproduced here yet; the license
 column is filled in as part of release review, and the SBOM records
 `NOASSERTION` until then rather than guessing.
 
-## hy-memory 2.0.7
+## hy-memory 2.0.9
 
 License: Apache-2.0
 

memhub/apps/cli/src/cli-logs.test.ts

@@ -162,10 +162,54 @@ it("never emits a secret from a malformed manually written event", async () => {
     command: "logs",
     state: "empty",
     events: 0,
-    invalid_lines: 1,
+    invalid_lines: 0,
+    unrecognized_lines: 1,
   });
 });
 
+// After an upgrade the files still hold an older build's records. They are
+// whole JSON lines the reader leaves out, not damage, so the text output must
+// not warn about them; only a line that is not JSON is called damaged.
+it("warns only about lines that are not JSON, not about older records", async () => {
+  const dataDir = await fixture();
+  const older = {
+    schema_version: 0,
+    service: "desktop",
+    component: "desktop.lifecycle",
+    event: "desktop.started",
+  };
+  await writeFile(
+    path.join(dataDir, "logs", "diagnostic-desktop.jsonl"),
+    `${JSON.stringify(older)}\n${JSON.stringify({ ...older, schema_version: 1 })}\n`,
+    { mode: 0o600 },
+  );
+  let stdout = "";
+  let stderr = "";
+  vi.spyOn(process.stdout, "write").mockImplementation((value) => {
+    stdout += String(value);
+    return true;
+  });
+  vi.spyOn(process.stderr, "write").mockImplementation((value) => {
+    stderr += String(value);
+    return true;
+  });
+
+  expect(await run(["logs"], { ONE_MEMORY_DATA_DIR: dataDir })).toBe(0);
+  expect(stdout).toContain("core.start_failed");
+  expect(stdout).not.toContain("损坏");
+  expect(stderr).toBe("");
+
+  await writeFile(
+    path.join(dataDir, "logs", "diagnostic-cli.jsonl"),
+    '{"schema_version": 1, "event": \n',
+    { mode: 0o600 },
+  );
+  stdout = "";
+  expect(await run(["logs"], { ONE_MEMORY_DATA_DIR: dataDir })).toBe(0);
+  expect(stdout).toContain("跳过 1 行损坏的诊断记录。");
+  expect(stderr).toBe("memhub: 跳过 1 行损坏的诊断记录。\n");
+});
+
 it("rejects invalid filters without touching the log directory", async () => {
   const dataDir = path.join(
     await mkdtemp(path.join(os.tmpdir(), "om-cli-no-log-")),

memhub/apps/cli/src/cli.ts

@@ -190,8 +190,10 @@ import {
 } from "./managed-cli-link.js";
 import {
   addMemory,
+  DEFAULT_USER_ID,
   isMemoryId,
   isRequestId,
+  isUserId,
   MEMORY_KINDS,
   MEMORY_SCENES,
   MEMORY_VARIANTS,
@@ -209,6 +211,7 @@ import {
   renderMemoryAddText,
   renderMemoryDetailText,
   renderMemoryPageText,
+  userIdParameters,
   validMemoryText,
 } from "./memory-report.js";
 import {
@@ -538,6 +541,23 @@ async function runCommand(
       environment = { ...environment, ONE_MEMORY_DATA_DIR: lifted.dataDir };
     }
   }
+  // `--user-id <id>` is global to the memory commands: it names whose
+  // memories are read or written. It is lifted before dispatch so each
+  // command's own parser keeps seeing exactly the arguments it always did.
+  // `sources connect` gives the flag its own meaning and parses it itself.
+  let userId: string | undefined;
+  if (USER_ID_COMMANDS.has(arguments_[0] ?? "")) {
+    const lifted = liftUserIdOption(arguments_);
+    if (lifted === null) {
+      return reject(
+        findCommand(arguments_[0] ?? ""),
+        asJson,
+        "--user-id 无效：只能是 1–64 位字母、数字、点、下划线或连字符。",
+      );
+    }
+    arguments_ = lifted.arguments_;
+    userId = lifted.userId;
+  }
   environment = await environmentWithManagedDataDir(environment);
   const command = arguments_[0];
   if (command === undefined) return reject(undefined, asJson, "缺少命令。");
@@ -776,9 +796,11 @@ async function runCommand(
     const attachment = await attachToRuntimeOrNull(environment);
     if (attachment === null) return runtimeUnavailable(descriptor, asJson);
     if (parsed.kind === "status") {
-      const receipt = await readMemoryWrite(attachment, parsed.id).catch(
-        () => undefined,
-      );
+      const receipt = await readMemoryWrite(
+        attachment,
+        parsed.id,
+        userId,
+      ).catch(() => undefined);
       if (receipt === undefined) {
         return emitFailure(asJson, "write status", "memory_write_read_failed");
       }
@@ -812,6 +834,7 @@ async function runCommand(
         ? {}
         : { memory_at: parsed.memory_at }),
       ...(parsed.priority === undefined ? {} : { priority: parsed.priority }),
+      ...(userId === undefined ? {} : { user_id: userId }),
     });
     if (outcome.state !== "accepted") {
       emit(
@@ -957,9 +980,12 @@ async function runCommand(
                 state: "empty",
                 events: 0,
                 invalid_lines: report.invalid_lines,
+                unrecognized_lines: report.unrecognized_lines,
               })}\n`
           : renderLogText(report.events, report.invalid_lines),
       );
+      // Only lines that are not JSON are damage. Records an older build wrote
+      // are left out without a warning: after an upgrade they are expected.
       if (report.invalid_lines) {
         process.stderr.write(
           `${PRODUCT}: 跳过 ${report.invalid_lines} 行损坏的诊断记录。\n`,
@@ -1582,6 +1608,7 @@ async function runCommand(
           limit: parsed.limit,
           character_budget: parsed.characterBudget,
           timeout_ms: parsed.timeoutMs,
+          ...userIdParameters(userId),
         })
       : ({
           schema_version: 2,
@@ -1780,6 +1807,16 @@ async function runCommand(
   }
   if (named === "sources" && arguments_[1] !== "list") {
     const parsed = parseSourcesCommand(arguments_.slice(1));
+    if (
+      !parsed &&
+      arguments_.some((item) => item === "--user-id" || item === "--root")
+    ) {
+      return reject(
+        descriptor,
+        asJson,
+        "--user-id 和 --root 只能用于接入单个 hermes 来源（Hermes profile），用户 ID 只能是 1–64 位字母、数字、点、下划线或连字符。",
+      );
+    }
     if (!parsed) return usage();
     if (parsed.kind === "receipt") {
       const connected = await connectRuntime(environment);
@@ -2004,7 +2041,11 @@ async function runCommand(
       );
       return connected.exitCode;
     }
-    const outcome = await connected.reader<unknown>("/api/v2/user-profile");
+    const profileUser = userIdParameters(userId);
+    const outcome =
+      profileUser.user_id === undefined
+        ? await connected.reader<unknown>("/api/v2/user-profile")
+        : await connected.reader<unknown>("/api/v2/user-profile", profileUser);
     const value =
       outcome.state === "ok"
         ? (outcome.data as {
@@ -2109,7 +2150,7 @@ async function runCommand(
     }
     const { reader, operations } = connected;
     if (parsed.kind === "list") {
-      const document = await readMemoryPage(reader, parsed.query);
+      const document = await readMemoryPage(reader, parsed.query, userId);
       emit(
         asJson
           ? `${JSON.stringify(document)}\n`
@@ -2122,6 +2163,7 @@ async function runCommand(
         reader,
         parsed.memoryId,
         parsed.namespace,
+        userId,
       );
       emit(
         asJson
@@ -2133,8 +2175,8 @@ async function runCommand(
     if (parsed.kind === "add" || parsed.kind === "add-status") {
       const document =
         parsed.kind === "add"
-          ? await addMemory(operations, text ?? "", parsed.requestId)
-          : await readMemoryAddStatus(reader, parsed.requestId);
+          ? await addMemory(operations, text ?? "", parsed.requestId, userId)
+          : await readMemoryAddStatus(reader, parsed.requestId, userId);
       emit(
         asJson
           ? `${JSON.stringify(document)}\n`
@@ -2149,9 +2191,13 @@ async function runCommand(
             content: text,
             ...namespaceParameters(parsed.namespace),
             ...(parsed.task === undefined ? {} : { task: parsed.task }),
+            ...userIdParameters(userId),
           })
         : await operations.delete<unknown>(
-            withQuery(memoryPath, namespaceParameters(parsed.namespace)),
+            withQuery(memoryPath, {
+              ...namespaceParameters(parsed.namespace),
+              ...userIdParameters(userId),
+            }),
           );
     const document = {
       schema_version: 2,
@@ -3675,13 +3721,21 @@ async function connectSources(
       asJson,
     );
   }
-  if (parsed.importHistory) {
+  // Another user's Hermes profile is granted and imported in one connect
+  // request: only that request can carry a user and a root.
+  if (
+    parsed.importHistory ||
+    parsed.userId !== undefined ||
+    parsed.root !== undefined
+  ) {
     const document = await connectSourcesWithImport(reader, operations, {
       sourceIds: parsed.sourceIds,
       confirmOverrides: parsed.confirmOverrides,
       ...(parsed.requestId === undefined
         ? {}
         : { requestId: parsed.requestId }),
+      ...(parsed.userId === undefined ? {} : { userId: parsed.userId }),
+      ...(parsed.root === undefined ? {} : { root: parsed.root }),
     });
     emitFlowDocument(document, asJson);
     return flowExitCode(document);
@@ -4101,6 +4155,8 @@ const SDK_MIGRATION_FAILURES: Record<string, string> = {
     "核对发现新版本还读不到你的全部记忆，没有切换数据源。",
   sdk_migration_model_profile_required:
     "迁移需要先有可用的模型配置，用来核对新版本能否读回记忆。请先用 memhub models setup 完成配置，再运行 memhub restart 重试。",
+  sdk_migration_vector_profile_missing:
+    "记忆的向量来自一个已删除的模型配置，当前配置读不回它们，所以没有迁移。请重新添加并启用那个模型配置，再运行 memhub restart 重试。",
 };
 
 const MIGRATION_ISSUES_URL =
@@ -5131,14 +5187,23 @@ type SourcesCommand =
       importHistory: boolean;
       confirmOverrides: boolean;
       requestId?: string;
+      /** `--user-id`: whose grant (Hermes only). Absent for `local`. */
+      userId?: string;
+      /** `--root`: an absolute root other than the candidate (Hermes only). */
+      root?: string;
     }
   | { kind: "all"; importHistory: boolean; confirmOverrides: boolean }
   | { kind: "receipt"; requestId: string };
 
 const SOURCE_ID_SHAPE = /^[a-z0-9][a-z0-9-]{0,127}$/;
 
+/** Only Hermes keeps one history per profile, so only Hermes may be
+ * connected for another user or from another root. */
+const MULTI_USER_SOURCES = new Set(["hermes"]);
+
 /** `sources connect <id> [<id> ...] | --all-detected [--import]
- * [--confirm-overrides] [--request-id <uuid>]` and `sources receipt <id>`.
+ * [--confirm-overrides] [--request-id <uuid>]
+ * [--user-id <id>] [--root <path>]` and `sources receipt <id>`.
  *
  * Sources may be named positionally or with repeated `--source` (the old
  * `init --source` spelling is rewritten to this command). */
@@ -5154,6 +5219,8 @@ function parseSourcesCommand(rest: readonly string[]): SourcesCommand | null {
   const sourceIds: string[] = [];
   const switches = new Set<string>();
   let requestId: string | undefined;
+  let userId: string | undefined;
+  let root: string | undefined;
   for (let index = 1; index < tokens.length; index += 1) {
     const token = tokens[index];
     if (["--import", "--confirm-overrides", "--all-detected"].includes(token)) {
@@ -5161,6 +5228,21 @@ function parseSourcesCommand(rest: readonly string[]): SourcesCommand | null {
       switches.add(token);
       continue;
     }
+    if (token === "--user-id" || token === "--root") {
+      const value = tokens[index + 1];
+      if (value === undefined || value.startsWith("--")) return null;
+      if (token === "--user-id") {
+        if (userId !== undefined || !isUserId(value)) return null;
+        userId = value;
+      } else {
+        if (root !== undefined) return null;
+        const expanded = expandRootPath(value);
+        if (expanded === null) return null;
+        root = expanded;
+      }
+      index += 1;
+      continue;
+    }
     if (token === "--source" || token === "--request-id") {
       const value = tokens[index + 1];
       if (value === undefined || value.startsWith("--")) return null;
@@ -5184,10 +5266,23 @@ function parseSourcesCommand(rest: readonly string[]): SourcesCommand | null {
   const confirmOverrides = switches.has("--confirm-overrides");
   if (
     requestId !== undefined &&
-    (!OPERATION_ID.test(requestId) || !importHistory)
+    (!OPERATION_ID.test(requestId) ||
+      !(importHistory || userId !== undefined || root !== undefined))
   ) {
     return null;
   }
+  // `--user-id local` is the default and changes nothing.
+  if (userId === DEFAULT_USER_ID) userId = undefined;
+  if (userId !== undefined || root !== undefined) {
+    // One Hermes profile per connect: the user and root name one grant.
+    if (
+      switches.has("--all-detected") ||
+      sourceIds.length !== 1 ||
+      !MULTI_USER_SOURCES.has(sourceIds[0])
+    ) {
+      return null;
+    }
+  }
   if (switches.has("--all-detected")) {
     // One names exact sources, the other means "whatever is detected".
     if (sourceIds.length > 0 || requestId !== undefined) return null;
@@ -5200,9 +5295,24 @@ function parseSourcesCommand(rest: readonly string[]): SourcesCommand | null {
     importHistory,
     confirmOverrides,
     ...(requestId === undefined ? {} : { requestId }),
+    ...(userId === undefined ? {} : { userId }),
+    ...(root === undefined ? {} : { root }),
   };
 }
 
+/** `--root` as an absolute path: a leading `~` is the home directory, a
+ * relative path is taken from the working directory. Core expands nothing. */
+function expandRootPath(value: string): string | null {
+  if (value.length === 0 || /[\0\r\n]/.test(value)) return null;
+  const expanded =
+    value === "~"
+      ? os.homedir()
+      : value.startsWith("~/")
+        ? path.join(os.homedir(), value.slice(2))
+        : value;
+  return path.resolve(expanded);
+}
+
 function parseGraphWidthCommand(
   rest: readonly string[],
 ): { decision: GraphWidthDecision; confirmed: boolean } | null {
@@ -6596,6 +6706,30 @@ const OWN_DATA_DIR_COMMANDS = new Set([
 
 /** Remove one `--data-dir <absolute path>` from argv; null when it is
  * repeated, missing its value, or not an absolute path. */
+/** Memory commands that honour the global `--user-id`. */
+const USER_ID_COMMANDS = new Set(["memories", "recall", "profile", "write"]);
+
+/**
+ * Take `--user-id <id>` out of the arguments. The default user (`local`) is
+ * returned as undefined, so a default request names no user at all and stays
+ * byte-identical to one sent before multi-user support.
+ */
+function liftUserIdOption(
+  arguments_: readonly string[],
+): { arguments_: string[]; userId?: string } | null {
+  const index = arguments_.indexOf("--user-id");
+  if (index === -1) return { arguments_: [...arguments_] };
+  if (arguments_.indexOf("--user-id", index + 1) !== -1) return null;
+  const value = arguments_[index + 1];
+  if (value === undefined || value.startsWith("--") || !isUserId(value)) {
+    return null;
+  }
+  return {
+    arguments_: [...arguments_.slice(0, index), ...arguments_.slice(index + 2)],
+    ...(value === DEFAULT_USER_ID ? {} : { userId: value }),
+  };
+}
+
 function liftDataDirOption(
   arguments_: readonly string[],
 ): { arguments_: string[]; dataDir?: string } | null {

memhub/apps/cli/src/command-catalog.ts

@@ -68,6 +68,12 @@ const JSON_OPTION: CommandOption = {
   flag: "--json",
   summary: "以 JSON 输出到 stdout，供脚本与 Agent 消费。",
 };
+/** Global to the memory commands: whose memories are read or written. */
+const USER_ID_OPTION: CommandOption = {
+  flag: "--user-id <id>",
+  summary:
+    "读写哪个用户的记忆，默认 local（App 用的就是 local）。1–64 位字母、数字、点、下划线或连字符；其他用户的记忆来自用 sources connect hermes --user-id 接入的 Hermes profile。",
+};
 const WATCH_OPTION: CommandOption = {
   flag: "--watch",
   summary: "串行持续刷新；Ctrl-C 只停止观察，不停止 Runtime。",
@@ -252,15 +258,25 @@ export const COMMANDS: readonly CommandDescriptor[] = [
   {
     name: "sources",
     summary:
-      "列出来源，直接接入来源，或按 request id 查接入回执。connect 不加 --import 只授权（处理保持冻结：不导入历史、不扫描新会话）；加 --import 同时导入历史并开启持续同步，返回 request id。目录来自环境变量覆盖的来源必须加 --confirm-overrides。",
+      "列出来源，直接接入来源，或按 request id 查接入回执。connect 不加 --import 只授权（处理保持冻结：不导入历史、不扫描新会话）；加 --import 同时导入历史并开启持续同步，返回 request id。目录来自环境变量覆盖的来源必须加 --confirm-overrides。Hermes 的每个 profile 是一个独立用户：用 --user-id 和 --root 接入，授权并导入历史（会自动排除 ~/.hermes/profiles/**，各用户互不读取）。",
     usage:
-      "memhub sources list [--json]\n            memhub sources connect <id> [<id> ...] [--import] [--confirm-overrides] [--request-id <uuid>] [--json]\n            memhub sources connect --all-detected [--import] [--confirm-overrides] [--json]\n            memhub sources receipt <request-id> [--json]",
+      "memhub sources list [--json]\n            memhub sources connect <id> [<id> ...] [--import] [--confirm-overrides] [--request-id <uuid>] [--json]\n            memhub sources connect hermes --user-id <id> --root <path> [--import] [--request-id <uuid>] [--json]\n            memhub sources connect --all-detected [--import] [--confirm-overrides] [--json]\n            memhub sources receipt <request-id> [--json]",
     options: [
       {
         flag: "--import",
         summary:
           "接入后立即导入历史会话并开启持续同步；不加时只授权，处理保持冻结。",
       },
+      {
+        flag: "--user-id <id>",
+        summary:
+          "只用于 hermes：这条接入属于哪个用户（默认 local）。和 --root 一起接入一个 Hermes profile，例如 --user-id wife --root ~/.hermes/profiles/wife；其他来源只能是 local。",
+      },
+      {
+        flag: "--root <path>",
+        summary:
+          "只用于 hermes：读取的根目录（~ 会展开为主目录）。默认是 Hermes 自己的目录 ~/.hermes。",
+      },
       {
         flag: "--all-detected",
         summary:
@@ -373,7 +389,7 @@ export const COMMANDS: readonly CommandDescriptor[] = [
     summary:
       "列出、搜索、查看、添加、修改或物理删除记忆（对话、工作、编码三个场景）。add 和 App 的「添加记忆」是同一个入口；delete 不可逆，需 --yes。",
     usage:
-      "memhub memories list [--scene <all|chat|working|coding>] [--source <id>] [--query <text>] [--status <state>] [--offset <n>] [--limit <n>] [--json]\n            memhub memories show <memory-id> [--kind <kind>] [--variant <variant>] [--json]\n            memhub memories add <text> [--request-id <uuid>] [--json]\n            memhub memories add --content-file <path> [--request-id <uuid>] [--json]\n            memhub memories add-status <request-id> [--json]\n            memhub memories update <memory-id> --content-file <path> [--kind <kind>] [--variant <variant>] [--task <text>] [--json]\n            memhub memories delete <memory-id> [--kind <kind>] [--variant <variant>] [--yes] [--json]",
+      "memhub memories list [--scene <all|chat|working|coding>] [--source <id>] [--query <text>] [--status <state>] [--offset <n>] [--limit <n>] [--user-id <id>] [--json]\n            memhub memories show <memory-id> [--kind <kind>] [--variant <variant>] [--user-id <id>] [--json]\n            memhub memories add <text> [--request-id <uuid>] [--user-id <id>] [--json]\n            memhub memories add --content-file <path> [--request-id <uuid>] [--user-id <id>] [--json]\n            memhub memories add-status <request-id> [--user-id <id>] [--json]\n            memhub memories update <memory-id> --content-file <path> [--kind <kind>] [--variant <variant>] [--task <text>] [--user-id <id>] [--json]\n            memhub memories delete <memory-id> [--kind <kind>] [--variant <variant>] [--yes] [--user-id <id>] [--json]",
     options: [
       {
         flag: "--scene <all|chat|working|coding>",
@@ -411,6 +427,7 @@ export const COMMANDS: readonly CommandDescriptor[] = [
           "add 的幂等键；用同一个 id 重试只会读回第一次的结果，不会重复添加。不给时自动生成并输出。",
       },
       DESTRUCTIVE_CONFIRM_OPTION,
+      USER_ID_OPTION,
       JSON_OPTION,
     ],
     exit_codes: RUNTIME_EXITS,
@@ -418,8 +435,8 @@ export const COMMANDS: readonly CommandDescriptor[] = [
   {
     name: "profile",
     summary: "读取 SDK 组装后的用户长期画像（L0 + 已启用的长期画像补充）。",
-    usage: "memhub profile [--json]",
-    options: [JSON_OPTION],
+    usage: "memhub profile [--user-id <id>] [--json]",
+    options: [USER_ID_OPTION, JSON_OPTION],
     exit_codes: RUNTIME_EXITS,
   },
   {
@@ -475,7 +492,7 @@ export const COMMANDS: readonly CommandDescriptor[] = [
     summary:
       "从原始对话与已沉淀记忆统一检索上下文；本地只读，不调用模型、不触发补索引。文本输出标明每条是「原始对话摘录」还是「记忆」（JSON 里是 kind: raw|memory）。",
     usage:
-      "memhub recall <query> [--kind <raw|memory>] [--source <id>] [--limit <n>] [--character-budget <n>] [--timeout-ms <n>] [--json]\n            memhub recall --query-file <path> [...]\n            memhub recall --stdin [...]",
+      "memhub recall <query> [--kind <raw|memory>] [--source <id>] [--limit <n>] [--character-budget <n>] [--timeout-ms <n>] [--user-id <id>] [--json]\n            memhub recall --query-file <path> [...]\n            memhub recall --stdin [...]",
     options: [
       {
         flag: "--query-file <path>",
@@ -502,6 +519,7 @@ export const COMMANDS: readonly CommandDescriptor[] = [
         flag: "--timeout-ms <n>",
         summary: "Core 查询时限 50..30000 毫秒，默认 2000。",
       },
+      USER_ID_OPTION,
       JSON_OPTION,
     ],
     exit_codes: RUNTIME_EXITS,
@@ -650,7 +668,7 @@ export const COMMANDS: readonly CommandDescriptor[] = [
     summary:
       "提交一段 OpenAI 格式的对话（messages）到写入队列，异步加工成记忆；或按 request id 查询状态。request id 是幂等键：不给时自动生成并输出，重试请带上同一个。新增一条结论式记忆请用 memories add。",
     usage:
-      "memhub write submit --messages-file <path> --session <id> [--source <id>] [--request-id <id>] [--memory-at <RFC3339>] [--live] [--json]\n            memhub write status <request-id> [--json]",
+      "memhub write submit --messages-file <path> --session <id> [--source <id>] [--request-id <id>] [--memory-at <RFC3339>] [--live] [--user-id <id>] [--json]\n            memhub write status <request-id> [--user-id <id>] [--json]",
     options: [
       {
         flag: "--messages-file <path>",
@@ -666,6 +684,7 @@ export const COMMANDS: readonly CommandDescriptor[] = [
       },
       { flag: "--memory-at <RFC3339>", summary: "对话发生时间，必须带时区。" },
       { flag: "--live", summary: "优先处理。" },
+      USER_ID_OPTION,
       JSON_OPTION,
     ],
     exit_codes: RUNTIME_EXITS,

memhub/apps/cli/src/context-search.ts

@@ -10,6 +10,8 @@ export interface ContextSearchInput {
   limit: number;
   character_budget: number;
   timeout_ms: number;
+  /** Whose memories to search. Omitted for the default user (`local`). */
+  user_id?: string;
 }
 
 /** The CLI's JSON document mirrors Core's SDK-native context schema v2. */

memhub/apps/cli/src/core-client.ts

@@ -12,6 +12,7 @@ const READ_ONLY_PATHS = [
   "/api/v1/live-sync",
   "/api/v1/memory-processing",
   "/api/v1/model-profiles",
+  "/api/v1/source-grants",
   "/api/v1/sources",
   "/api/v2/home-summary",
   "/api/v2/memory-library",
@@ -310,6 +311,8 @@ export async function submitMemoryWrite(
     messages: readonly OpenAIMessage[];
     memory_at?: string;
     priority?: "live" | "normal";
+    /** Whose memory this is. Omitted for the default user (`local`). */
+    user_id?: string;
   },
 ): Promise<MemoryWriteOutcome> {
   let response: { status: number; data: unknown };
@@ -327,6 +330,9 @@ export async function submitMemoryWrite(
         ...(request.priority === undefined
           ? {}
           : { priority: request.priority }),
+        ...(request.user_id === undefined || request.user_id === "local"
+          ? {}
+          : { user_id: request.user_id }),
       },
       {
         headers: { Authorization: `Bearer ${attachment.apiToken}` },
@@ -469,11 +475,16 @@ export async function deleteModelProfile(
 export async function readMemoryWrite(
   attachment: RuntimeAttachmentLike,
   requestId: string,
+  /** A receipt belongs to the user that submitted it; omit for `local`. */
+  userId?: string,
 ): Promise<MemoryWriteReceipt | null> {
   try {
     const response = await axios.get<MemoryWriteReceipt>(
       `${baseUrlOf(attachment)}/api/v2/memory-writes/${encodeURIComponent(requestId)}`,
       {
+        ...(userId === undefined || userId === "local"
+          ? {}
+          : { params: { user_id: userId } }),
         headers: { Authorization: `Bearer ${attachment.apiToken}` },
         timeout: 10_000,
         proxy: false,

memhub/apps/cli/src/core-operations.ts

@@ -6,9 +6,10 @@ const WRITE_PATHS = [
 ] as const;
 /** `POST /api/v2/memories` adds one memory (the app's 添加记忆). */
 const MEMORY_ADD_PATH = "/api/v2/memories";
-/** One SDK memory; delete names its namespace in the query string. */
+/** One SDK memory; delete names its namespace, and a non-default user, in
+ * the query string. */
 const SDK_MEMORY_PATH =
-  /^\/api\/v2\/memories\/[A-Za-z0-9][\w.-]{0,127}(?:\?kind=(?:chat|experience|fact)(?:&variant=(?:working|coding))?)?$/;
+  /^\/api\/v2\/memories\/[A-Za-z0-9][\w.-]{0,127}(?:\?(?:kind=(?:chat|experience|fact)(?:&variant=(?:working|coding))?(?:&user_id=[A-Za-z0-9._-]{1,64})?|user_id=[A-Za-z0-9._-]{1,64}))?$/;
 const MODEL_PROBE_PATH =
   /^\/api\/v1\/model-profiles\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/probe$/;
 const MODEL_PROFILE_PATH =

memhub/apps/cli/src/headless-flows.ts

@@ -110,9 +110,18 @@ export async function connectSourcesWithImport(
     sourceIds: readonly string[];
     confirmOverrides: boolean;
     requestId?: string;
+    /** Whose grant this is. Omitted for the default user (`local`). */
+    userId?: string;
+    /** An absolute root other than the source's candidate (a Hermes
+     * profile). Core reads its identity itself, so the source's candidate
+     * root id and revision are not sent for it. */
+    root?: string;
   },
 ): Promise<FlowDocument> {
   const sourceIds = input.sourceIds;
+  // A second user's grant is not a first run, and a custom root has no
+  // candidate the app showed: both are a plain connect.
+  const profile = input.root !== undefined || input.userId !== undefined;
   if (
     sourceIds.length < 1 ||
     sourceIds.length > 32 ||
@@ -134,9 +143,14 @@ export async function connectSourcesWithImport(
     return invalid("source_unavailable");
   }
   const items = selected.map(([candidate]) => candidate);
-  const needsOverride = items
-    .filter((item) => item.requires_override_confirmation)
-    .map((item) => item.source_id);
+  // A custom root is the caller's own choice, not the environment override
+  // the confirmation exists for.
+  const needsOverride =
+    input.root !== undefined
+      ? []
+      : items
+          .filter((item) => item.requires_override_confirmation)
+          .map((item) => item.source_id);
   if (needsOverride.length > 0 && !input.confirmOverrides) {
     return {
       schema_version: 1,
@@ -154,18 +168,22 @@ export async function connectSourcesWithImport(
     request = buildSourceImportRequest({
       sourceIds: [...sourceIds],
       sourceRoots: Object.fromEntries(
-        items.map((item) => [item.source_id, item.candidate_root_id]),
+        items.flatMap((item) =>
+          input.root === undefined
+            ? [[item.source_id, item.candidate_root_id]]
+            : [],
+        ),
       ),
       sourceCandidateRevisions: Object.fromEntries(
         items.flatMap((item) =>
-          item.candidate_revision === undefined
+          item.candidate_revision === undefined || input.root !== undefined
             ? []
             : [[item.source_id, item.candidate_revision]],
         ),
       ),
       confirmEnvironmentOverrides: needsOverride.length > 0,
       fullRescan: false,
-      onboarding: true,
+      onboarding: !profile,
       enableSync: true,
       requestId,
     });
@@ -175,7 +193,11 @@ export async function connectSourcesWithImport(
     }
     throw error;
   }
-  const result = await operations.post<unknown>(request.path, request.body);
+  const result = await operations.post<unknown>(request.path, {
+    ...request.body,
+    ...(input.userId === undefined ? {} : { user_id: input.userId }),
+    ...(input.root === undefined ? {} : { root: input.root }),
+  });
   if (result.state === "rejected") {
     return rejected(requestId, result.code);
   }

memhub/apps/cli/src/log-report.ts

@@ -107,7 +107,11 @@ export async function readLogReport(
   query: LogQuery,
 ): Promise<{
   events: DiagnosticEventV1[];
+  /** Lines that are not JSON: the only ones `memhub logs` calls damaged. */
   invalid_lines: number;
+  /** Whole JSON lines the reader leaves out, such as an older build's
+   * records. Nothing is wrong with them, so the text output says nothing. */
+  unrecognized_lines: number;
   failure?: "log_directory_unreadable";
 }> {
   // `readDiagnosticEvents` treats an unreadable logs path as "no events". That
@@ -119,6 +123,7 @@ export async function readLogReport(
     return {
       events: [],
       invalid_lines: 0,
+      unrecognized_lines: 0,
       failure: "log_directory_unreadable",
     };
   }
@@ -129,6 +134,7 @@ export async function readLogReport(
     return {
       events: [],
       invalid_lines: 0,
+      unrecognized_lines: 0,
       failure: "log_directory_unreadable",
     };
   }

memhub/apps/cli/src/memory-report.ts

@@ -14,6 +14,25 @@ import { type CoreReader, RESERVED_MEMORY_SEGMENTS } from "./core-client.js";
 import type { CoreOperations } from "./core-operations.js";
 import { PRODUCT } from "./version.js";
 
+/** A MemHub user id, the same shape Core accepts. `local` is the default. */
+const USER_ID = /^[A-Za-z0-9._-]{1,64}$/;
+export const DEFAULT_USER_ID = "local";
+
+export function isUserId(value: string): boolean {
+  return USER_ID.test(value);
+}
+
+/**
+ * The `user_id` to send, or nothing. The default user is never named on the
+ * wire, so a request without `--user-id` stays exactly what it was before
+ * multi-user support and still works against an older Core.
+ */
+export function userIdParameters(userId?: string): { user_id?: string } {
+  return userId === undefined || userId === DEFAULT_USER_ID
+    ? {}
+    : { user_id: userId };
+}
+
 /** Output budget: a long memory is shortened visibly, never dropped silently. */
 const CONTENT_BUDGET = 240;
 
@@ -101,10 +120,12 @@ export interface MemoryDetailDocument {
 export async function readMemoryPage(
   reader: CoreReader,
   query: MemoryQuery,
+  userId?: string,
 ): Promise<MemoryPageDocument> {
   const parameters: Record<string, string | number> = {
     offset: query.offset,
     limit: query.limit,
+    ...userIdParameters(userId),
   };
   if (query.status !== undefined) parameters.statuses = query.status;
   if (query.source !== undefined) parameters.source = query.source;
@@ -156,8 +177,12 @@ export async function readMemoryDetail(
   reader: CoreReader,
   memoryId: string,
   namespace: MemoryNamespace = {},
+  userId?: string,
 ): Promise<MemoryDetailDocument> {
-  const parameters = namespaceParameters(namespace);
+  const parameters = {
+    ...namespaceParameters(namespace),
+    ...userIdParameters(userId),
+  };
   const outcome = await reader<unknown>(
     `/api/v2/memories/${memoryId}`,
     Object.keys(parameters).length > 0 ? parameters : undefined,
@@ -236,6 +261,7 @@ export async function addMemory(
   operations: CoreOperations,
   text: string,
   requestId: string = randomUUID(),
+  userId?: string,
 ): Promise<MemoryAddDocument> {
   const base = {
     schema_version: 2 as const,
@@ -259,7 +285,10 @@ export async function addMemory(
     }
     throw error;
   }
-  const result = await operations.post<unknown>(request.path, request.body);
+  const result = await operations.post<unknown>(request.path, {
+    ...request.body,
+    ...userIdParameters(userId),
+  });
   if (result.state !== "committed") {
     return { ...base, state: result.state, code: result.code };
   }
@@ -273,6 +302,7 @@ export async function addMemory(
 export async function readMemoryAddStatus(
   reader: CoreReader,
   requestId: string,
+  userId?: string,
 ): Promise<MemoryAddDocument> {
   const base = {
     schema_version: 2 as const,
@@ -283,7 +313,11 @@ export async function readMemoryAddStatus(
   if (!UUID.test(requestId)) {
     return { ...base, state: "invalid", code: "invalid_request_id" };
   }
-  const outcome = await reader<unknown>(memoryAddStatusPath(requestId));
+  const user = userIdParameters(userId);
+  const outcome =
+    user.user_id === undefined
+      ? await reader<unknown>(memoryAddStatusPath(requestId))
+      : await reader<unknown>(memoryAddStatusPath(requestId), user);
   if (outcome.state === "not_found") {
     return { ...base, state: "not_found", code: "memory_add_not_found" };
   }

memhub/apps/cli/src/source-progress-report.ts

@@ -38,6 +38,21 @@ export interface SourcesDocument {
   state: ReadState["state"];
   code?: string;
   sources: Array<Record<string, unknown>>;
+  /** Every grant of every user (`GET /api/v1/source-grants`). Absent when
+   * Core is too old to list them; `sources` is the default user's view. */
+  grants?: SourceGrant[];
+}
+
+/** One source grant. Only Hermes has grants for users other than `local`,
+ * one per Hermes profile root. */
+export interface SourceGrant {
+  user_id: string;
+  source_id: string;
+  root_label: string | null;
+  root_path: string | null;
+  authorized: boolean;
+  revoked_at: string | null;
+  sync_enabled: boolean;
 }
 
 export interface SyncDocument {
@@ -86,14 +101,66 @@ export async function readSources(
       sources: [],
     };
   }
+  const grants = await readSourceGrants(reader);
   return {
     schema_version: SCHEMA_VERSION,
     product: PRODUCT,
     state: "ok",
-    sources: result.data.map(projectSource),
+    // `/api/v1/sources` is the default user's view of every source.
+    sources: result.data.map((source) => ({
+      ...projectSource(source),
+      user_id: "local",
+    })),
+    ...(grants === null ? {} : { grants }),
   };
 }
 
+/** The grants of every user, or null when Core cannot list them (an older
+ * Core answers 404): the source list is then shown as before. */
+async function readSourceGrants(
+  reader: CoreReader,
+): Promise<SourceGrant[] | null> {
+  let outcome: ReadOutcome<unknown>;
+  try {
+    outcome = await reader<unknown>("/api/v1/source-grants");
+  } catch {
+    return null;
+  }
+  if (outcome.state !== "ok") return null;
+  const value = outcome.data;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const items = (value as { grants?: unknown }).grants;
+  if (!Array.isArray(items)) return null;
+  const grants: SourceGrant[] = [];
+  const text = (candidate: unknown): string | null =>
+    typeof candidate === "string" && candidate.length <= 4096
+      ? candidate
+      : null;
+  for (const item of items) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+    const grant = item as Record<string, unknown>;
+    if (
+      typeof grant.user_id !== "string" ||
+      !/^[A-Za-z0-9._-]{1,64}$/.test(grant.user_id) ||
+      typeof grant.source_id !== "string" ||
+      !/^[a-z0-9][a-z0-9-]{0,127}$/.test(grant.source_id) ||
+      typeof grant.authorized !== "boolean"
+    ) {
+      return null;
+    }
+    grants.push({
+      user_id: grant.user_id,
+      source_id: grant.source_id,
+      root_label: text(grant.root_label),
+      root_path: text(grant.root_path),
+      authorized: grant.authorized,
+      revoked_at: text(grant.revoked_at),
+      sync_enabled: grant.sync_enabled === true,
+    });
+  }
+  return grants;
+}
+
 export async function readSync(reader: CoreReader): Promise<SyncDocument> {
   const result = validated(
     await reader<unknown>("/api/v1/live-sync"),
@@ -231,6 +298,22 @@ export function renderSourcesText(document: SourcesDocument): string {
     );
   }
   if (document.sources.length === 0) lines.push("（没有来源）");
+  // The list above is the default user's (`local`). Another user's grant,
+  // a Hermes profile, is listed with its user so it is not mistaken for it.
+  const others = (document.grants ?? []).filter(
+    (grant) => grant.user_id !== "local",
+  );
+  if (others.length > 0) {
+    lines.push("其他用户的连接：");
+    for (const grant of others) {
+      const name =
+        document.sources.find((source) => source.source_id === grant.source_id)
+          ?.display_name ?? grant.source_id;
+      lines.push(
+        `- ${name}（用户 ${grant.user_id}）：${grant.authorized ? "已连接" : grant.revoked_at ? "已撤销" : "未连接"}；处理${grant.sync_enabled ? "已开启" : "已冻结"}${grant.root_path ? `；目录 ${grant.root_path}` : ""}`,
+      );
+    }
+  }
   lines.push("");
   return lines.join("\n");
 }

memhub/apps/cli/src/source-progress.test.ts

@@ -179,12 +179,72 @@ describe("CLI-07/10 source and synchronization reads", () => {
       sync_enabled: true,
       sync_completeness: "additions_only",
     });
-    expect(requestedPaths()).toEqual(["/api/v1/sources"]);
+    // The grants list answers 404 here, as an older Core does: the source
+    // list is shown as before, every row the default user's.
+    expect(report.sources[0].user_id).toBe("local");
+    expect(report.grants).toBeUndefined();
+    expect(requestedPaths()).toEqual([
+      "/api/v1/sources",
+      "/api/v1/source-grants",
+    ]);
     expect(requestedPaths().some((path) => path.includes("detect"))).toBe(
       false,
     );
   });
 
+  it("shows every user's grant, a Hermes profile with its user", async () => {
+    const grants = {
+      schema_version: 1,
+      grants: [
+        {
+          user_id: "local",
+          source_id: "codex",
+          root_label: ".codex",
+          root_path: "/home/synthetic/.codex",
+          authorized: true,
+          revoked_at: null,
+          sync_enabled: true,
+        },
+        {
+          user_id: "wife",
+          source_id: "hermes",
+          root_label: "wife",
+          root_path: "/home/synthetic/.hermes/profiles/wife",
+          authorized: true,
+          revoked_at: null,
+          sync_enabled: true,
+        },
+      ],
+    };
+    transport.get.mockImplementation(async (url: string) =>
+      url === "/api/v1/source-grants"
+        ? { status: 200, data: grants }
+        : (RESPONSES.get(url) ?? { status: 404, data: {} }),
+    );
+    let streams = captureStreams();
+    try {
+      expect(await run(["sources", "list", "--json"], {})).toBe(0);
+    } finally {
+      streams.restore();
+    }
+    const report = JSON.parse(streams.stdout());
+    expect(report.grants).toEqual(grants.grants);
+    expect(report.sources[0]).toMatchObject({
+      source_id: "codex",
+      user_id: "local",
+    });
+    streams = captureStreams();
+    try {
+      expect(await run(["sources", "list"], {})).toBe(0);
+    } finally {
+      streams.restore();
+    }
+    expect(streams.stdout()).toContain("其他用户的连接：");
+    expect(streams.stdout()).toContain(
+      "hermes（用户 wife）：已连接；处理已开启；目录 /home/synthetic/.hermes/profiles/wife",
+    );
+  });
+
   it("keeps degraded synchronization distinct and prints its error code", async () => {
     const streams = captureStreams();
     try {
@@ -552,6 +612,7 @@ describe("CLI-19 progress and issue reads", () => {
       requestedPaths().every((path) =>
         [
           "/api/v1/sources",
+          "/api/v1/source-grants",
           "/api/v1/live-sync",
           "/api/v1/import-jobs",
           "/api/v1/memory-processing",

memhub/apps/cli/src/user-id-cli.test.ts

@@ -0,0 +1,405 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import os, { tmpdir } from "node:os";
+import path from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { run } from "./cli.js";
+
+const transport = vi.hoisted(() => ({
+  get: vi.fn(),
+  post: vi.fn(),
+  put: vi.fn(),
+  patch: vi.fn(),
+  delete: vi.fn(),
+}));
+const direct = vi.hoisted(() => ({ get: vi.fn(), post: vi.fn() }));
+vi.mock("axios", () => ({
+  default: {
+    create: vi.fn(() => transport),
+    get: direct.get,
+    post: direct.post,
+    isAxiosError: () => false,
+  },
+}));
+
+const runtime = vi.hoisted(() => ({
+  inspectRuntimeStatus: vi.fn(),
+  discoverRuntimeAttachment: vi.fn(),
+}));
+vi.mock("@one-memory/runtime-control", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@one-memory/runtime-control")>()),
+  ...runtime,
+}));
+
+const REQUEST = "33333333-3333-4333-8333-333333333333";
+const HERMES = {
+  source_id: "hermes",
+  display_name: "Hermes",
+  storage_kinds: ["sqlite"],
+  available: true,
+  authorized: true,
+  detected: null,
+  root_label: ".hermes",
+  candidate_path: "~/.hermes",
+  candidate_kind: "default",
+  candidate_revision: 0,
+  candidate_root_id: "hermes-root-identity",
+  imported_messages: 0,
+  imported_conversations: 0,
+  capabilities: {
+    historical_import: "implemented",
+    incremental_import: "implemented",
+    live_sync: "implemented",
+    recall: "implemented",
+    installer: "not_implemented",
+    verification: "fixture_only",
+  },
+  sync_completeness: "additions_only",
+  location_state: "found",
+};
+const CODEX = {
+  ...HERMES,
+  source_id: "codex",
+  display_name: "Codex",
+  candidate_root_id: "codex-root-identity",
+};
+
+function addReceipt() {
+  return {
+    evidence_id: "44444444-4444-4444-8444-444444444444",
+    text: "Prefers tea",
+    scope: "all-apps",
+    created_at: "2026-10-27T00:00:00Z",
+    state: "pending",
+    task_id: null,
+    memory_ids: [],
+    error: null,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  for (const method of [
+    ...Object.values(transport),
+    ...Object.values(direct),
+  ]) {
+    method.mockReset();
+  }
+  runtime.inspectRuntimeStatus.mockResolvedValue({
+    state: "running",
+    code: "runtime_verified",
+    instanceId: "instance-1",
+    host: "127.0.0.1",
+    port: 8765,
+    version: "1.2.3",
+  });
+  runtime.discoverRuntimeAttachment.mockResolvedValue({
+    instanceId: "instance-1",
+    apiToken: "synthetic-runtime-token",
+    host: "127.0.0.1",
+    port: 8765,
+    servicePid: 4242,
+    health: {
+      status: "ok",
+      service: "one-memory-core",
+      version: "1.2.3",
+      instance_id: "instance-1",
+    },
+  });
+  transport.get.mockImplementation(async (url: string) => {
+    if (url === "/api/v1/sources") {
+      return { status: 200, data: [HERMES, CODEX] };
+    }
+    if (url === "/api/v2/user-profile") {
+      return {
+        status: 200,
+        data: { request_id: "r-1", profile: null, elapsed_ms: 1 },
+      };
+    }
+    return { status: 404, data: {} };
+  });
+  transport.post.mockImplementation(
+    async (url: string, body: Record<string, unknown>) =>
+      url === "/api/v1/sources/connect"
+        ? {
+            status: 200,
+            data: {
+              request_id: body.request_id,
+              accepted_source_ids: ["hermes"],
+              failed_sources: {},
+              jobs: [],
+            },
+          }
+        : url === "/api/v2/memories"
+          ? { status: 201, data: addReceipt() }
+          : { status: 404, data: {} },
+  );
+  transport.put.mockResolvedValue({ status: 200, data: {} });
+  transport.delete.mockResolvedValue({ status: 204, data: "" });
+  direct.post.mockResolvedValue({
+    status: 202,
+    data: {
+      request_id: REQUEST,
+      state: "accepted",
+      created_at: "T1",
+      updated_at: "T1",
+    },
+  });
+  direct.get.mockResolvedValue({
+    data: {
+      request_id: REQUEST,
+      state: "accepted",
+      created_at: "T1",
+      updated_at: "T1",
+    },
+  });
+});
+
+describe("--user-id on the memory commands", () => {
+  it("passes the user as a query parameter to memory reads and deletes", async () => {
+    await capturedRun(["memories", "list", "--user-id", "wife", "--json"]);
+    expect(transport.get).toHaveBeenCalledWith("/api/v2/memory-library", {
+      params: { offset: 0, limit: 100, user_id: "wife" },
+    });
+    // Global: the flag may come before the subcommand too.
+    await capturedRun(["memories", "--user-id", "wife", "show", "m-1"]);
+    expect(transport.get).toHaveBeenCalledWith("/api/v2/memories/m-1", {
+      params: { user_id: "wife" },
+    });
+    await capturedRun(["memories", "add-status", REQUEST, "--user-id", "wife"]);
+    expect(transport.get).toHaveBeenCalledWith(
+      `/api/v2/memories/additions/${REQUEST}`,
+      { params: { user_id: "wife" } },
+    );
+    await capturedRun(["profile", "--user-id", "wife", "--json"]);
+    expect(transport.get).toHaveBeenCalledWith("/api/v2/user-profile", {
+      params: { user_id: "wife" },
+    });
+    await capturedRun([
+      "memories",
+      "delete",
+      "fact-1",
+      "--kind",
+      "fact",
+      "--yes",
+      "--user-id",
+      "wife",
+    ]);
+    expect(transport.delete).toHaveBeenCalledWith(
+      "/api/v2/memories/fact-1?kind=fact&user_id=wife",
+      undefined,
+    );
+    await capturedRun([
+      "memories",
+      "delete",
+      "m-1",
+      "--yes",
+      "--user-id",
+      "wife",
+    ]);
+    expect(transport.delete).toHaveBeenCalledWith(
+      "/api/v2/memories/m-1?user_id=wife",
+      undefined,
+    );
+    await capturedRun(["write", "status", REQUEST, "--user-id", "wife"]);
+    expect(direct.get.mock.calls[0][0]).toBe(
+      `http://127.0.0.1:8765/api/v2/memory-writes/${REQUEST}`,
+    );
+    expect(direct.get.mock.calls[0][1].params).toEqual({ user_id: "wife" });
+  });
+
+  it("passes the user in the body of memory writes and searches", async () => {
+    await capturedRun(["memories", "add", "Prefers tea", "--user-id", "wife"]);
+    expect(transport.post.mock.calls[0][0]).toBe("/api/v2/memories");
+    expect(transport.post.mock.calls[0][1]).toMatchObject({
+      text: "Prefers tea",
+      scope: "all-apps",
+      user_id: "wife",
+    });
+    const directory = await mkdtemp(path.join(tmpdir(), "om-user-id-"));
+    const content = path.join(directory, "content.txt");
+    await writeFile(content, "Prefers green tea\n");
+    await capturedRun([
+      "memories",
+      "update",
+      "m-1",
+      "--content-file",
+      content,
+      "--user-id",
+      "wife",
+    ]);
+    expect(transport.put.mock.calls[0][0]).toBe("/api/v2/memories/m-1");
+    expect(transport.put.mock.calls[0][1]).toMatchObject({ user_id: "wife" });
+    await capturedRun(["recall", "tea", "--user-id", "wife", "--json"]);
+    const search = transport.post.mock.calls.find(
+      ([url]) => url === "/api/v2/context/search",
+    );
+    expect(search?.[1]).toMatchObject({ query: "tea", user_id: "wife" });
+    const messages = path.join(directory, "messages.json");
+    await writeFile(
+      messages,
+      JSON.stringify([{ role: "user", content: "I like tea" }]),
+    );
+    await capturedRun([
+      "write",
+      "submit",
+      "--messages-file",
+      messages,
+      "--session",
+      "s-1",
+      "--user-id",
+      "wife",
+    ]);
+    expect(direct.post.mock.calls[0][0]).toBe(
+      "http://127.0.0.1:8765/api/v2/memory-writes",
+    );
+    expect(direct.post.mock.calls[0][1]).toMatchObject({
+      session_id: "s-1",
+      user_id: "wife",
+    });
+  });
+
+  it("names no user by default or for --user-id local", async () => {
+    for (const extra of [[], ["--user-id", "local"]]) {
+      transport.get.mockClear();
+      transport.post.mockClear();
+      await capturedRun(["memories", "list", ...extra, "--json"]);
+      expect(transport.get).toHaveBeenCalledWith("/api/v2/memory-library", {
+        params: { offset: 0, limit: 100 },
+      });
+      await capturedRun(["profile", ...extra]);
+      expect(transport.get).toHaveBeenCalledWith(
+        "/api/v2/user-profile",
+        undefined,
+      );
+      await capturedRun(["memories", "add", "Prefers tea", ...extra]);
+      expect(transport.post.mock.calls[0][1]).not.toHaveProperty("user_id");
+      await capturedRun(["recall", "tea", ...extra, "--json"]);
+      const search = transport.post.mock.calls.find(
+        ([url]) => url === "/api/v2/context/search",
+      );
+      expect(search?.[1]).not.toHaveProperty("user_id");
+    }
+  });
+
+  it("refuses a malformed user id before contacting Core", async () => {
+    for (const value of ["bad:id", "", "x".repeat(65), "a b", "--json"]) {
+      const result = await capturedRun([
+        "memories",
+        "list",
+        "--user-id",
+        value,
+      ]);
+      expect(result.code).toBe(2);
+    }
+    expect(
+      (await capturedRun(["profile", "--user-id", "a", "--user-id", "b"])).code,
+    ).toBe(2);
+    expect((await capturedRun(["recall", "tea", "--user-id"])).code).toBe(2);
+    expect(transport.get).not.toHaveBeenCalled();
+    expect(transport.post).not.toHaveBeenCalled();
+  });
+});
+
+describe("sources connect for a Hermes profile", () => {
+  it("connects hermes for another user from its own root", async () => {
+    const result = await capturedRun([
+      "sources",
+      "connect",
+      "hermes",
+      "--user-id",
+      "wife",
+      "--root",
+      "~/.hermes/profiles/wife",
+      "--json",
+    ]);
+    expect(result.code).toBe(0);
+    expect(transport.post).toHaveBeenCalledTimes(1);
+    const [url, body] = transport.post.mock.calls[0];
+    expect(url).toBe("/api/v1/sources/connect");
+    expect(body).toMatchObject({
+      source_ids: ["hermes"],
+      // Core reads the custom root's identity itself.
+      source_roots: {},
+      source_candidate_revisions: {},
+      onboarding: false,
+      user_id: "wife",
+      root: path.join(os.homedir(), ".hermes/profiles/wife"),
+    });
+  });
+
+  it("keeps a plain connect unchanged and accepts --import with a profile", async () => {
+    await capturedRun(["sources", "connect", "hermes", "--import", "--json"]);
+    const plain = transport.post.mock.calls[0][1];
+    expect(plain).not.toHaveProperty("user_id");
+    expect(plain).not.toHaveProperty("root");
+    expect(plain).toMatchObject({
+      source_roots: { hermes: "hermes-root-identity" },
+      onboarding: true,
+    });
+    transport.post.mockClear();
+    const result = await capturedRun([
+      "sources",
+      "connect",
+      "hermes",
+      "--import",
+      "--user-id",
+      "wife",
+      "--root",
+      "/profiles/wife",
+      "--request-id",
+      REQUEST,
+      "--json",
+    ]);
+    expect(result.code).toBe(0);
+    expect(transport.post.mock.calls[0][1]).toMatchObject({
+      request_id: REQUEST,
+      user_id: "wife",
+      root: "/profiles/wife",
+    });
+  });
+
+  it("refuses --user-id and --root for any source but hermes", async () => {
+    for (const argv of [
+      ["sources", "connect", "codex", "--user-id", "wife"],
+      ["sources", "connect", "codex", "--root", "/somewhere", "--import"],
+      ["sources", "connect", "hermes", "codex", "--user-id", "wife"],
+      ["sources", "connect", "--all-detected", "--user-id", "wife"],
+      ["sources", "connect", "hermes", "--user-id", "bad:id"],
+    ]) {
+      const result = await capturedRun(argv);
+      expect(result.code).toBe(2);
+      expect(result.stderr).toContain("hermes");
+    }
+    expect(transport.post).not.toHaveBeenCalled();
+  });
+});
+
+async function capturedRun(arguments_: string[]) {
+  let stdout = "";
+  let stderr = "";
+  const stdoutSpy = vi
+    .spyOn(process.stdout, "write")
+    .mockImplementation((chunk) => {
+      stdout += String(chunk);
+      return true;
+    });
+  const stderrSpy = vi
+    .spyOn(process.stderr, "write")
+    .mockImplementation((chunk) => {
+      stderr += String(chunk);
+      return true;
+    });
+  try {
+    return {
+      code: await run(arguments_, {
+        ONE_MEMORY_DATA_DIR: "/synthetic/data",
+      }),
+      stdout,
+      stderr,
+    };
+  } finally {
+    stdoutSpy.mockRestore();
+    stderrSpy.mockRestore();
+  }
+}

memhub/apps/core/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "fastapi>=0.141.1",
     "filelock>=3.32.4",
     # Public SDK version validated against MemHub's permission and recall contracts.
-    "hy-memory==2.0.7",
+    "hy-memory==2.0.9",
     # chromadb arrives through the HY SDK; locked here so an unrelated upgrade
     # cannot move the SDK's store. Built-in embedding consumes numpy directly.
     "chromadb==1.5.9",

memhub/apps/core/src/one_memory/api.py

@@ -14,6 +14,7 @@ from collections.abc import (
     MutableMapping,
 )
 from contextlib import asynccontextmanager, nullcontext, suppress
+from dataclasses import replace
 from datetime import UTC, datetime, timedelta
 from functools import partial
 from pathlib import Path
@@ -93,7 +94,6 @@ from one_memory.hy_runtime_config import (
 from one_memory.hy_sdk_runtime import (
     AmbiguousMemoryIdError,
     SdkClientHandle,
-    builtin_retrieval_snapshot,
     close_all_shared_runtimes,
     hold_stores_offline,
     release_stores,
@@ -117,6 +117,7 @@ from one_memory.imports.access import (
     AuthorizedSourceRoot,
     SourceAccessError,
     root_identity_matches,
+    source_root_identity,
 )
 from one_memory.imports.adapters import (
     ScanFailure,
@@ -157,6 +158,7 @@ from one_memory.imports.sources.common import SourceInstallState
 from one_memory.imports.sources.registry import (
     RootCandidateKind,
     SourceRegistration,
+    SourceRootCandidate,
     build_source_catalog,
     workbuddy_default_homes,
 )
@@ -187,6 +189,7 @@ from one_memory.model_presets import seed_preset_profile
 from one_memory.model_probe import ModelProber, ModelProbeResult
 from one_memory.model_profiles import (
     ActiveModelProfileError,
+    EmbeddingBaseUrlRequiredError,
     ModelCreationOperationConflictError,
     ModelCreationOperationLookupError,
     ModelCreationOperationReceipt,
@@ -226,6 +229,7 @@ from one_memory.sdk_memory_qa import (
 )
 from one_memory.sdk_memory_runtime import SdkMemoryRuntime
 from one_memory.sdk_migration_log import error_chain_text, error_frames
+from one_memory.sdk_read_handle import ActiveProfileReadHandle
 from one_memory.sdk_write_processor import SdkWriteCoordinator
 from one_memory.secrets import (
     KeyringSecretStore,
@@ -244,7 +248,17 @@ from one_memory.service_levels import (
 from one_memory.source_import_receipts import SourceImportReceipt, build_source_import_receipt
 from one_memory.source_read_access import SourceReadAccess
 from one_memory.source_totals import SourceTotals
+from one_memory.strict_query import forbid_unknown_query_params
 from one_memory.target_schema import bootstrap_fresh_management_schema
+from one_memory.user_scope import (
+    DEFAULT_USER_ID,
+    MULTI_USER_SOURCES,
+    USER_ID_PATTERN,
+    UserId,
+    lane_key,
+    owns,
+    split_lane,
+)
 from one_memory.workspace_resolution import resolve_workspace_scopes
 
 logger = logging.getLogger(__name__)
@@ -387,6 +401,12 @@ class CreateImportJobRequest(BaseModel):
 
 class ConnectSourcesRequest(BaseModel):
     source_ids: tuple[str, ...] = Field(min_length=1, max_length=32)
+    #: Whose grant this is. Only Hermes may connect a root for a user other
+    #: than `local`: a Hermes profile is another person's history.
+    user_id: UserId = DEFAULT_USER_ID
+    #: A root chosen by the caller instead of the source's candidate, such as
+    #: `~/.hermes/profiles/<name>`. Hermes only; Core computes its identity.
+    root: str | None = Field(default=None, min_length=1, max_length=4096)
     confirm_environment_overrides: bool = False
     full_rescan: bool = False
     onboarding: bool = False
@@ -422,6 +442,8 @@ class SdkMemoryUpdateRequest(BaseModel):
     variant: SdkMemoryVariant | None = None
     # Experiences only: also replace the task.
     task: str | None = Field(default=None, min_length=1, max_length=200_000)
+    #: Whose memory this is; another user's id answers 404.
+    user_id: UserId = DEFAULT_USER_ID
 
 
 class SdkUserProfileResponse(BaseModel):
@@ -584,11 +606,15 @@ class ManualExtractReceipt(BaseModel):
 
 
 class AskMemoryRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
     question: str = Field(min_length=1, max_length=2_000)
     scope: str = Field(default="all-apps", min_length=1, max_length=512)
     # Host-injected project directory, same boundary as recall. Optional so
     # the web UI and older callers keep working unchanged.
     workspace_path: str | None = Field(default=None, max_length=4_096)
+    #: Whose memories answer. Omitted, it is `local`, the App's library.
+    user_id: UserId = DEFAULT_USER_ID
 
 
 class SdkHomeSummary(BaseModel):
@@ -626,6 +652,27 @@ class MemoryGraphResponse(BaseModel):
     hy_graph_available: bool = True
 
 
+class SourceGrantView(BaseModel):
+    """One `(user_id, source_id)` grant, as `GET /api/v1/source-grants` lists it."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    user_id: str
+    source_id: str
+    root_label: str
+    root_path: str
+    authorized: bool
+    revoked_at: datetime | None
+    sync_enabled: bool
+
+
+class SourceGrantList(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    schema_version: Literal[1] = 1
+    grants: tuple[SourceGrantView, ...]
+
+
 class SdkMigrationRequired(RuntimeError):
     """A serving Core was started on a home that is not on SDK authority."""
 
@@ -876,6 +923,16 @@ def create_app(
                     )
                 except sqlite3.Error as error:
                     app.state.memory_visibility_error = str(error)
+            else:
+                # A home an earlier build migrated still carries the grant
+                # triggers whose body reads a dropped table (#233).
+                try:
+                    await asyncio.to_thread(
+                        memory_visibility.drop_stale_triggers,
+                        database_path,
+                    )
+                except sqlite3.Error as error:
+                    app.state.memory_visibility_error = str(error)
             model_request_budget = (
                 ModelRequestBudget(
                     database_path,
@@ -928,6 +985,7 @@ def create_app(
                 write_queue=memory_write_queue,
                 extraction_settings=app.state.extraction_settings_store,
                 data_dir=runtime_settings.data_dir,
+                user_ids=lambda: _known_user_ids(app),
             )
             # C2 owns the single production budget (handle 5s + reserve 250ms,
             # total 5.25s, lease 10s, renew 1s, claim 250ms). The composition
@@ -1100,6 +1158,13 @@ def create_app(
                 source_id
                 for source_id, registration in app.state.source_catalog.items()
                 if registration.capabilities.live_sync is CapabilityState.IMPLEMENTED
+            ) + tuple(
+                lane
+                for lane in _other_user_lanes(
+                    app.state.source_catalog, app.state.source_grant_store
+                )
+                if app.state.source_catalog[split_lane(lane)[1]].capabilities.live_sync
+                is CapabilityState.IMPLEMENTED
             )
             # Resolved before the supervisor is built so it can state truthfully
             # how it is being driven: watching only applies to roots that exist
@@ -1496,9 +1561,12 @@ def create_app(
         Depends(local_api_guard(runtime_settings, valid_ui_session=ui_session_valid)),
         Depends(require_external_endpoint),
     ]
-    app.include_router(memory_add_router(protected))
+    # Memory reads and writes refuse a query parameter they do not declare: an
+    # ignored `user_id` would read as isolation that never happened.
+    strict = [*protected, Depends(forbid_unknown_query_params)]
+    app.include_router(memory_add_router(strict))
     app.include_router(file_import_router(protected))
-    app.include_router(sdk_context_router(protected))
+    app.include_router(sdk_context_router(strict))
 
     # A4-01: scan-root configuration, so the CLI's `path` command has something
     # to read instead of refusing.
@@ -1512,7 +1580,7 @@ def create_app(
 
     if getattr(app.state, "memory_write_registry", None) is None:
         app.state.memory_write_registry = WriteRegistry()
-    app.include_router(sdk_memory_write_router(protected))
+    app.include_router(sdk_memory_write_router(strict))
     from one_memory.call_event_routes import call_event_router
 
     app.include_router(call_event_router(protected))
@@ -2287,7 +2355,11 @@ def create_app(
         return SourceSyncState(source_id=source_id, sync_enabled=request.enabled)
 
     async def _prepare_source_resume(source_id: str) -> None:
-        """Prepare catch-up work before committing the new desired state."""
+        """Prepare catch-up work before committing the new desired state.
+
+        `source_id` is a lane key, so another user's lane prepares that
+        user's own cursors and history job.
+        """
         await _live_sync(app).initialize_source(source_id, baseline_missing_files=True)
         active = {
             ImportStatus.PENDING,
@@ -2297,14 +2369,17 @@ def create_app(
             ImportStatus.FAILED,
         }
         if any(
-            job.source_id == source_id and job.operation == "history" and job.status in active
+            lane_key(job.user_id, job.source_id) == source_id
+            and job.operation == "history"
+            and job.status in active
             for job in _job_store(app).list_jobs()
         ):
             return
+        user_id, bare_source_id = split_lane(source_id)
         await asyncio.to_thread(
             _job_store(app).create,
-            user_id="local",
-            source_id=source_id,
+            user_id=user_id,
+            source_id=bare_source_id,
             operation="history",
         )
 
@@ -2312,7 +2387,7 @@ def create_app(
         """Run work prepared for a source after config.json has committed."""
         try:
             for job in _job_store(app).list_jobs():
-                if job.source_id != source_id:
+                if lane_key(job.user_id, job.source_id) != source_id:
                     continue
                 if job.status is ImportStatus.PENDING:
                     _supervisor(app).enqueue(job.job_id)
@@ -2341,8 +2416,13 @@ def create_app(
         response_model=SourceGrantReceipt,
         dependencies=protected,
     )
-    async def revoke_source(source_id: str) -> SourceGrantReceipt:
+    async def revoke_source(
+        source_id: str,
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
+    ) -> SourceGrantReceipt:
         _require_registration(app, source_id)
+        if user_id != DEFAULT_USER_ID:
+            return await _revoke_other_user_grant(source_id, user_id)
         receipt = _grant_store(app).receipt(
             user_id="local",
             source_id=source_id,
@@ -2378,6 +2458,65 @@ def create_app(
         await _refresh_live_watch(app)
         return receipt
 
+    async def _revoke_other_user_grant(source_id: str, user_id: str) -> SourceGrantReceipt:
+        """Stop reading another user's root. The App's switch is left alone."""
+        if source_id not in MULTI_USER_SOURCES:
+            raise HTTPException(status_code=422, detail="user_id_requires_multi_user_source")
+        lane = lane_key(user_id, source_id)
+        receipt = await asyncio.to_thread(
+            partial(_grant_store(app).receipt, user_id=user_id, source_id=source_id)
+        )
+        if receipt is None:
+            raise HTTPException(status_code=404, detail="grant_not_found")
+        active_statuses = {
+            ImportStatus.PENDING,
+            ImportStatus.RUNNING,
+            ImportStatus.PAUSED,
+            ImportStatus.INTERRUPTED,
+            ImportStatus.FAILED,
+        }
+        for job in _job_store(app).list_jobs():
+            if lane_key(job.user_id, job.source_id) == lane and job.status in active_statuses:
+                await _supervisor(app).cancel(job.job_id)
+        await _live_sync(app).stop_source(lane)
+        _supervisor(app).unregister_adapter(lane)
+        receipt = await asyncio.to_thread(
+            partial(_grant_store(app).revoke, user_id=user_id, source_id=source_id)
+        )
+        await _refresh_live_watch(app)
+        return receipt
+
+    @app.get(
+        "/api/v1/source-grants",
+        response_model=SourceGrantList,
+        dependencies=protected,
+    )
+    async def list_source_grants() -> SourceGrantList:
+        """Every grant of every user. `/api/v1/sources` stays `local`'s, as the App reads it."""
+
+        def describe() -> SourceGrantList:
+            config_store = _config_store(app)
+            views = []
+            for receipt, root_path in _grant_store(app).grants():
+                lane = lane_key(receipt.user_id, receipt.source_id)
+                authorized = receipt.revoked_at is None and receipt.revision > 0
+                views.append(
+                    SourceGrantView(
+                        user_id=receipt.user_id,
+                        source_id=receipt.source_id,
+                        root_label=receipt.root_label,
+                        root_path=_display_candidate_path(
+                            Path(root_path), runtime_settings.source_home
+                        ),
+                        authorized=authorized,
+                        revoked_at=receipt.revoked_at,
+                        sync_enabled=authorized and _lane_sync_enabled(config_store, lane),
+                    )
+                )
+            return SourceGrantList(grants=tuple(views))
+
+        return await asyncio.to_thread(describe)
+
     @app.post(
         "/api/v1/import-jobs",
         response_model=ImportJob,
@@ -2406,6 +2545,8 @@ def create_app(
     async def connect_sources(
         request: ConnectSourcesRequest,
     ) -> ConnectSourcesResponse:
+        if request.user_id != DEFAULT_USER_ID or request.root is not None:
+            return await _connect_other_root(request)
         if request.onboarding:
             app.state.history_import_gate_released = False
         source_ids = tuple(dict.fromkeys(request.source_ids))
@@ -2511,6 +2652,103 @@ def create_app(
                 raise
         return ConnectSourcesResponse(**result.model_dump())
 
+    async def _connect_other_root(request: ConnectSourcesRequest) -> ConnectSourcesResponse:
+        """Grant one Hermes root to a user: `~/.hermes/profiles/<name>` for its own user.
+
+        Only Hermes holds more than one person's history (one profile per
+        person), so a non-`local` user or a caller-chosen root is refused for
+        every other source. The grant is `(user_id, source_id)`; its cursors,
+        jobs and live sync follow that key.
+        """
+        source_ids = tuple(dict.fromkeys(request.source_ids))
+        if any(source_id not in MULTI_USER_SOURCES for source_id in source_ids):
+            raise HTTPException(status_code=422, detail="user_id_requires_multi_user_source")
+        if request.root is not None and len(source_ids) != 1:
+            raise HTTPException(status_code=422, detail="source_root_requires_one_source")
+        if request.user_id != DEFAULT_USER_ID and request.root is None:
+            # The user is the root that is read: another user must name theirs,
+            # or they would be handed `local`'s history.
+            raise HTTPException(status_code=422, detail="source_root_required_for_user")
+        if request.onboarding or request.import_upload_id is not None:
+            raise HTTPException(status_code=422, detail="user_id_unsupported_for_request")
+        if request.request_id is None:
+            raise HTTPException(status_code=409, detail="source_confirmation_required")
+        registrations = []
+        source_roots = dict(request.source_roots)
+        for source_id in source_ids:
+            registration = _require_registration(app, source_id)
+            if request.root is not None:
+                root = Path(request.root)
+                if not root.is_absolute():
+                    raise HTTPException(status_code=422, detail="source_root_must_be_absolute")
+                # Named outright by the caller, like an environment override:
+                # no saved candidate may replace it, and naming it confirms it.
+                registration = replace(
+                    registration,
+                    candidate=SourceRootCandidate(
+                        path=root, kind=RootCandidateKind.ENVIRONMENT_OVERRIDE
+                    ),
+                )
+                try:
+                    source_roots[source_id] = await asyncio.to_thread(source_root_identity, root)
+                except SourceAccessError as error:
+                    raise HTTPException(status_code=409, detail=error.code) from None
+            registrations.append(registration)
+        existing_intent = await asyncio.to_thread(
+            partial(
+                app.state.source_connection_store.get,
+                request.request_id,
+                user_id=request.user_id,
+            )
+        )
+        try:
+            result = await asyncio.to_thread(
+                partial(
+                    app.state.source_connection_store.connect,
+                    request_id=request.request_id,
+                    registrations=tuple(registrations),
+                    source_roots=source_roots,
+                    confirm_overrides=(
+                        request.confirm_environment_overrides or request.root is not None
+                    ),
+                    full_rescan=request.full_rescan,
+                    user_id=request.user_id,
+                )
+            )
+        except ConnectionIntentError as error:
+            raise HTTPException(status_code=409, detail=str(error)) from None
+        if existing_intent is not None:
+            return ConnectSourcesResponse(**result.model_dump())
+        for job in result.jobs:
+            registration = _require_registration(app, job.source_id)
+            grant = await asyncio.to_thread(
+                partial(
+                    _grant_store(app).authorized_root,
+                    user_id=job.user_id,
+                    source_id=job.source_id,
+                )
+            )
+            if grant is None:
+                continue
+            lane = lane_key(job.user_id, job.source_id)
+            _supervisor(app).register_adapter(
+                registration.create_adapter(grant), user_id=job.user_id
+            )
+            _detection(app).pop(lane, None)
+            if job.user_id != DEFAULT_USER_ID:
+                if registration.capabilities.live_sync is CapabilityState.IMPLEMENTED:
+                    _live_sync(app).ensure_source(lane)
+                # Another user's grant syncs while it stands (see
+                # `_lane_sync_enabled`); the App's switch is not touched.
+                await _prepare_source_resume(lane)
+                await _activate_source_resume(lane)
+            elif request.enable_sync:
+                await _prepare_source_resume(lane)
+                await asyncio.to_thread(_config_store(app).set_sync, job.source_id, True)
+                await _activate_source_resume(lane)
+        await _refresh_live_watch(app)
+        return ConnectSourcesResponse(**result.model_dump())
+
     @app.get(
         "/api/v1/source-connections/{request_id}",
         response_model=ConnectionIntentReceipt,
@@ -2527,8 +2765,12 @@ def create_app(
         response_model=list[ImportJob],
         dependencies=protected,
     )
-    def list_import_jobs() -> list[ImportJob]:
-        return _job_store(app).list_jobs()
+    def list_import_jobs(
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
+    ) -> list[ImportJob]:
+        # One user's jobs: the App reads `local`'s and must not show another
+        # user's Hermes import as its own.
+        return [job for job in _job_store(app).list_jobs() if job.user_id == user_id]
 
     @app.get(
         "/api/v1/live-sync",
@@ -2632,6 +2874,8 @@ def create_app(
     def create_model_profile(request: ModelProfileInput) -> ModelProfile:
         try:
             return _model_profile_store(app).create(request, _secret_store(app))
+        except EmbeddingBaseUrlRequiredError:
+            raise HTTPException(422, "embedding_base_url_required") from None
         except ModelCreationOperationConflictError:
             raise HTTPException(409, "model_creation_operation_conflict") from None
         except ModelCreationOperationLookupError:
@@ -2683,6 +2927,8 @@ def create_app(
             raise HTTPException(status_code=404, detail="model_profile_not_found") from None
         except ModelProfileConflictError:
             raise HTTPException(status_code=409, detail="model_profile_conflict") from None
+        except EmbeddingBaseUrlRequiredError:
+            raise HTTPException(status_code=422, detail="embedding_base_url_required") from None
         except SecretStoreUnavailableError as error:
             raise HTTPException(
                 status_code=503,
@@ -2857,9 +3103,11 @@ def create_app(
     @app.get(
         "/api/v2/home-summary",
         response_model=SdkHomeSummary,
-        dependencies=protected,
+        dependencies=strict,
     )
-    async def sdk_home_summary() -> SdkHomeSummary:
+    async def sdk_home_summary(
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
+    ) -> SdkHomeSummary:
         """The home card: the memory page's count and its newest memory.
 
         The count is `memory_stats` total (chat + working + coding
@@ -2871,12 +3119,12 @@ def create_app(
             client = await _sdk_client_handle(app).client()
             stats = await asyncio.to_thread(
                 client.memory_stats,
-                user_id="local",
+                user_id=user_id,
                 statuses=["active"],
             )
             raw = await asyncio.to_thread(
                 client.list_memories,
-                user_id="local",
+                user_id=user_id,
                 scene="all",
                 statuses=["active"],
                 limit=1,
@@ -2897,7 +3145,7 @@ def create_app(
     @app.get(
         "/api/v2/memory-library",
         response_model=HySdkMemoryPage,
-        dependencies=protected,
+        dependencies=strict,
     )
     async def sdk_memory_library(
         statuses: list[str] = Query(default=["active"]),  # noqa: B008
@@ -2907,6 +3155,7 @@ def create_app(
         limit: int = Query(default=LIBRARY_PAGE_SIZE, ge=1, le=500),
         window_id: str | None = Query(default=None, min_length=1, max_length=64),
         scene: Literal["all", "chat", "working", "coding"] = Query(default="all"),
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
     ) -> HySdkMemoryPage:
         """One page of memories across chat, working and coding.
 
@@ -2941,10 +3190,11 @@ def create_app(
                     limit=limit,
                     window_id=window_id,
                     scene=scene,
+                    user_id=user_id,
                 )
             raw = await asyncio.to_thread(
                 client.list_memories,
-                user_id="local",
+                user_id=user_id,
                 scene=scene,
                 statuses=list(statuses),
                 include_sources=[source] if source else None,
@@ -2965,12 +3215,13 @@ def create_app(
     @app.get(
         "/api/v2/memories/graph",
         response_model=MemoryGraphResponse,
-        dependencies=protected,
+        dependencies=strict,
     )
     async def sdk_memory_graph(
         limit: int = Query(default=160, ge=1, le=300),
         offset: int = Query(default=0, ge=0),
         source: str | None = Query(default=None, min_length=1),
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
     ) -> MemoryGraphResponse:
         """The memory map on SDK authority: SDK memories plus the Kuzu overlay.
 
@@ -2980,11 +3231,13 @@ def create_app(
         """
         try:
             client = await _sdk_client_handle(app).client()
-            # The map draws the page the list shows, so it reads the same
-            # source filter and window rather than the newest memories overall.
+            # The map visualizes the active source scope, independently of the
+            # left list's 20-row pagination window.
             raw = await asyncio.to_thread(
                 client.list_memories,
-                user_id="local",
+                user_id=user_id,
+                scene="all",
+                statuses=["active"],
                 include_sources=[source] if source else None,
                 limit=limit,
                 offset=offset,
@@ -3052,7 +3305,9 @@ def create_app(
         # source withholds the overlay, as on the legacy map.
         if not await asyncio.to_thread(_read_access(app).has_revoked_sources):
             try:
-                hy_graph = await _sdk_memory_runtime(app).graph_snapshot(limit=limit)
+                hy_graph = await _sdk_memory_runtime(app).graph_snapshot(
+                    limit=limit, user_id=user_id
+                )
             except HySdkError:
                 hy_graph = None
         if hy_graph is not None:
@@ -3102,12 +3357,14 @@ def create_app(
     @app.get(
         "/api/v2/user-profile",
         response_model=SdkUserProfileResponse,
-        dependencies=protected,
+        dependencies=strict,
     )
-    async def sdk_user_profile() -> SdkUserProfileResponse:
+    async def sdk_user_profile(
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
+    ) -> SdkUserProfileResponse:
         try:
             client = await _sdk_client_handle(app).client()
-            value = await asyncio.to_thread(client.get_user_profile, user_id="local")
+            value = await asyncio.to_thread(client.get_user_profile, user_id=user_id)
             profile = HySdkUserProfile.from_sdk(value)
         except Exception as error:
             raise _sdk_http_error(error, "hy_memory_profile_read_failed") from None
@@ -3116,18 +3373,23 @@ def create_app(
     @app.get(
         "/api/v2/memories/{memory_id}",
         response_model=HySdkMemoryRecord,
-        dependencies=protected,
+        dependencies=strict,
     )
     async def get_sdk_memory(
         memory_id: str,
         kind: SdkMemoryKind | None = None,
         variant: SdkMemoryVariant | None = None,
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
     ) -> HySdkMemoryRecord:
         _check_memory_namespace(kind, variant)
         try:
             memory = await _get_sdk_memory(
                 _sdk_client_handle(app), memory_id, kind=kind, variant=variant
             )
+            # The SDK's `get` takes no user: another user's memory reads as
+            # missing, never as existing.
+            if memory is not None and not owns(memory.user_id, user_id):
+                memory = None
         except AmbiguousMemoryIdError:
             raise HTTPException(status_code=409, detail="memory_id_ambiguous") from None
         except Exception as error:
@@ -3139,7 +3401,7 @@ def create_app(
     @app.put(
         "/api/v2/memories/{memory_id}",
         response_model=HySdkMemoryRecord,
-        dependencies=protected,
+        dependencies=strict,
     )
     async def update_sdk_memory(
         memory_id: str,
@@ -3150,25 +3412,32 @@ def create_app(
             raise HTTPException(status_code=422, detail="memory_task_requires_experience")
         namespace = _namespace_kwargs(request.kind, request.variant)
         try:
-            client = await app.state.sdk_write_coordinator.client()
-            update_kwargs: dict[str, object] = dict(namespace)
-            if request.task is not None:
-                update_kwargs["task"] = request.task
-            result = await asyncio.to_thread(
-                client.update, memory_id, request.content, **update_kwargs
-            )
-            if not isinstance(result, dict):
-                raise HySdkError("hy_memory_update_rejected")
-            if result.get("success") is not True:
-                if "not found" in str(result.get("error_message") or ""):
+            async with app.state.sdk_write_coordinator.use_client() as client:
+                # `update` takes no user: read the memory first and refuse
+                # another user's id exactly as a missing one.
+                current = await asyncio.to_thread(client.get, memory_id, **namespace)
+                if current is None or not owns(
+                    HySdkMemoryRecord.from_sdk(current).user_id, request.user_id
+                ):
                     raise HTTPException(status_code=404, detail="memory_not_found")
-                raise HySdkError("hy_memory_update_rejected")
-            # The SDK names the namespace it wrote; read that one back.
-            if result.get("kind") in {"experience", "fact"}:
-                namespace = {"kind": result["kind"]}
-                if result.get("variant") in {"working", "coding"}:
-                    namespace["variant"] = result["variant"]
-            raw = await asyncio.to_thread(client.get, memory_id, **namespace)
+                update_kwargs: dict[str, object] = dict(namespace)
+                if request.task is not None:
+                    update_kwargs["task"] = request.task
+                result = await asyncio.to_thread(
+                    client.update, memory_id, request.content, **update_kwargs
+                )
+                if not isinstance(result, dict):
+                    raise HySdkError("hy_memory_update_rejected")
+                if result.get("success") is not True:
+                    if "not found" in str(result.get("error_message") or ""):
+                        raise HTTPException(status_code=404, detail="memory_not_found")
+                    raise HySdkError("hy_memory_update_rejected")
+                # The SDK names the namespace it wrote; read that one back.
+                if result.get("kind") in {"experience", "fact"}:
+                    namespace = {"kind": result["kind"]}
+                    if result.get("variant") in {"working", "coding"}:
+                        namespace["variant"] = result["variant"]
+                raw = await asyncio.to_thread(client.get, memory_id, **namespace)
             memory = None if raw is None else HySdkMemoryRecord.from_sdk(raw)
         except HTTPException:
             raise
@@ -3188,19 +3457,30 @@ def create_app(
     @app.delete(
         "/api/v2/memories/{memory_id}",
         status_code=204,
-        dependencies=protected,
+        dependencies=strict,
     )
     async def delete_sdk_memory(
         memory_id: str,
         kind: SdkMemoryKind | None = None,
         variant: SdkMemoryVariant | None = None,
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
     ) -> Response:
         _check_memory_namespace(kind, variant)
         try:
-            client = await app.state.sdk_write_coordinator.client()
-            result = await asyncio.to_thread(
-                client.delete, memory_id, **_namespace_kwargs(kind, variant)
-            )
+            async with app.state.sdk_write_coordinator.use_client() as client:
+                # `delete` takes no user. Another user's memory is answered
+                # exactly like an id that does not exist: 204, nothing
+                # touched, so the status cannot tell that it exists.
+                current = await asyncio.to_thread(
+                    client.get, memory_id, **_namespace_kwargs(kind, variant)
+                )
+                if current is not None and not owns(
+                    HySdkMemoryRecord.from_sdk(current).user_id, user_id
+                ):
+                    return Response(status_code=204)
+                result = await asyncio.to_thread(
+                    client.delete, memory_id, **_namespace_kwargs(kind, variant)
+                )
             if not isinstance(result, dict):
                 raise HySdkError("hy_memory_delete_rejected")
             error_code = result.get("error_code")
@@ -3208,6 +3488,8 @@ def create_app(
                 raise HySdkError(str(error_code or "hy_memory_delete_incomplete"))
             if result.get("success") is not True and result.get("deleted_count") != 0:
                 raise HySdkError("hy_memory_delete_rejected")
+        except HTTPException:
+            raise
         except AmbiguousMemoryIdError:
             raise HTTPException(status_code=409, detail="memory_id_ambiguous") from None
         except Exception as error:
@@ -3217,18 +3499,19 @@ def create_app(
     @app.get(
         "/api/v2/raw",
         response_model=SdkRawPage,
-        dependencies=protected,
+        dependencies=strict,
     )
     async def sdk_raw_library(
         source: str | None = Query(default=None, min_length=1),
         offset: int = Query(default=0, ge=0),
         limit: int = Query(default=100, ge=1, le=500),
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
     ) -> SdkRawPage:
         try:
             client = await _sdk_client_handle(app).client()
             value = await asyncio.to_thread(
                 client.list_memories,
-                user_id="local",
+                user_id=user_id,
                 layers=["l1_raw"],
                 include_sources=[source] if source else None,
                 offset=offset,
@@ -3242,7 +3525,7 @@ def create_app(
     @app.post(
         "/api/v2/memories/ask",
         response_model=SdkMemoryAnswer,
-        dependencies=protected,
+        dependencies=strict,
     )
     async def ask_sdk_memories(
         request: AskMemoryRequest,
@@ -3259,7 +3542,9 @@ def create_app(
             "om_ask",
         )
         try:
-            answer = await _sdk_request_answerer(app).answer(request.question)
+            answer = await _sdk_request_answerer(app).answer(
+                request.question, user_id=request.user_id
+            )
         except MemoryAnswerError as error:
             raise HTTPException(status_code=503, detail=str(error)) from None
         if request.question != "__om_probe__" and access is not None:
@@ -3276,7 +3561,7 @@ def create_app(
 
     @app.post(
         "/api/v2/memories/ask/stream",
-        dependencies=protected,
+        dependencies=strict,
     )
     async def ask_sdk_memories_stream(
         request: AskMemoryRequest,
@@ -3298,7 +3583,9 @@ def create_app(
 
             final: dict[str, object] | None = None
             try:
-                async for event in answerer.answer_stream(request.question):
+                async for event in answerer.answer_stream(
+                    request.question, user_id=request.user_id
+                ):
                     if event.get("type") == "final":
                         final = event
                     yield _sse(_serialize_ask_event(event))
@@ -3329,7 +3616,7 @@ def create_app(
     @app.post(
         "/api/v1/recall",
         response_model=RecallReceipt,
-        dependencies=protected,
+        dependencies=strict,
     )
     async def recall_memories(
         request: RecallRequest,
@@ -3342,16 +3629,20 @@ def create_app(
         await _require_external_recall_scope(
             app, http_request, request.scope, request.workspace_path
         )
-        target = _recall_target(app)
+        target = (
+            _recall_target(app)
+            if request.user_id == DEFAULT_USER_ID
+            else _sdk_recall_target(app, request.user_id)
+        )
         access = external_access(http_request.headers)
         receipt = await recall_with_fallback(
             request,
             model_ready=lambda: _recall_model_ready(app),
             recall_memories=target.recall_async,
-            has_memories=lambda: _library_has_memories(app),
+            has_memories=lambda: _library_has_memories(app, request.user_id),
             raw_sources=lambda: _recall_raw_sources(app, request, access, started),
             search_raw=lambda query, limit, sources: _search_sdk_raw(
-                app, query, limit=limit, sources=sources
+                app, query, limit=limit, sources=sources, user_id=request.user_id
             ),
         )
         event_store = getattr(app.state, "call_event_store", None)
@@ -3442,9 +3733,9 @@ def create_app(
         """Retry unknown writes only behind the user's explicit confirmation."""
         del request
         reconciled = await _sdk_memory_runtime(app).reconcile_unknown_outputs()
-        from one_memory.memory_server.durable_queue import DurableWriteQueue
-
-        queue = DurableWriteQueue(app.state.memory_write_queue_path)
+        # The startup queue knows the authority. A fresh legacy-mode queue
+        # would recreate the job-evidence table the SDK cutover dropped.
+        queue = app.state.memory_write_queue
         unknown = queue.unknown_jobs(limit=2048)
         if app.state.memory_authority is MemoryAuthority.LEGACY:
             for job in unknown:
@@ -3728,21 +4019,60 @@ def _sync_refused(code: str) -> HTTPException:
     return HTTPException(status_code=409, detail=code)
 
 
+def _lane_sync_enabled(config_store: ConfigStore, lane: str) -> bool:
+    """Whether a lane may sync, before its grant is asked.
+
+    `local` keeps the App's per-source switch in the configuration document,
+    which stays global. Another user's Hermes grant syncs for as long as it
+    stands: connecting it is the consent, revoking it stops it, and it never
+    turns the App's switch on or off.
+    """
+    user_id, source_id = split_lane(lane)
+    if user_id == DEFAULT_USER_ID:
+        return config_store.sync_enabled(source_id)
+    return source_id in MULTI_USER_SOURCES
+
+
+def _other_user_lanes(
+    catalog: dict[str, SourceRegistration],
+    grant_store: SourceGrantStore,
+) -> tuple[str, ...]:
+    """Lanes of every unrevoked grant held by a user other than `local`."""
+    return tuple(
+        lane_key(receipt.user_id, receipt.source_id)
+        for receipt, _root in grant_store.grants()
+        if receipt.user_id != DEFAULT_USER_ID
+        and receipt.revoked_at is None
+        and receipt.source_id in MULTI_USER_SOURCES
+        and receipt.source_id in catalog
+    )
+
+
+def _known_user_ids(app: FastAPI) -> tuple[str, ...]:
+    """`local` and every user holding a grant: the users whose data Core keeps."""
+    users = [DEFAULT_USER_ID]
+    for receipt, _root in _grant_store(app).grants():
+        if receipt.user_id not in users:
+            users.append(receipt.user_id)
+    return tuple(users)
+
+
 def _granted_roots(
     source_ids: Iterable[str],
     grant_store: SourceGrantStore,
     config_store: ConfigStore,
 ) -> dict[str, Path]:
     roots: dict[str, Path] = {}
-    for source_id in source_ids:
-        if not config_store.sync_enabled(source_id):
+    for lane in source_ids:
+        if not _lane_sync_enabled(config_store, lane):
             continue
+        user_id, source_id = split_lane(lane)
         try:
-            grant = grant_store.authorized_root(user_id="local", source_id=source_id)
+            grant = grant_store.authorized_root(user_id=user_id, source_id=source_id)
         except SourceAccessError:
             continue
         if grant is not None:
-            roots[source_id] = grant.root
+            roots[lane] = grant.root
     return roots
 
 
@@ -3751,6 +4081,14 @@ def _active_adapters(
     grant_store: SourceGrantStore,
 ) -> dict[str, SourceAdapter]:
     adapters: dict[str, SourceAdapter] = {}
+    for lane in _other_user_lanes(catalog, grant_store):
+        user_id, source_id = split_lane(lane)
+        try:
+            grant = grant_store.authorized_root(user_id=user_id, source_id=source_id)
+            if grant is not None:
+                adapters[lane] = catalog[source_id].create_adapter(grant)
+        except SourceAccessError:
+            continue
     for source_id, registration in catalog.items():
         try:
             grant = grant_store.authorized_root(
@@ -3913,10 +4251,14 @@ def _config_store(app: FastAPI) -> ConfigStore:
 
 
 def _source_processing_enabled(app: FastAPI, source_id: str) -> bool:
-    if not _config_store(app).sync_enabled(source_id):
+    """`source_id` is a lane key: another user's lane asks that user's grant."""
+    if not _lane_sync_enabled(_config_store(app), source_id):
         return False
+    user_id, bare_source_id = split_lane(source_id)
     try:
-        return _grant_store(app).authorized_root(user_id="local", source_id=source_id) is not None
+        return (
+            _grant_store(app).authorized_root(user_id=user_id, source_id=bare_source_id) is not None
+        )
     except SourceAccessError:
         return False
 
@@ -4435,13 +4777,32 @@ async def _recall_model_ready(app: FastAPI) -> bool:
     return profile is not None and bool(profile.capabilities.model_available)
 
 
-async def _library_has_memories(app: FastAPI) -> bool:
+def _sdk_recall_target(app: FastAPI, user_id: str) -> SdkRecallTarget:
+    """Recall over one user's SDK memories; `get` results are kept only if theirs."""
+    handle = _sdk_client_handle(app)
+
+    async def owned(memory_id: str) -> HySdkMemoryRecord | None:
+        memory = await _get_sdk_memory(handle, memory_id)
+        return memory if memory is not None and owns(memory.user_id, user_id) else None
+
+    return SdkRecallTarget(
+        semantic_search=lambda query: _search_sdk_memories(
+            handle,
+            query,
+            user_id=user_id,
+            agent_id="*",
+        ),
+        get_memory=owned,
+    )
+
+
+async def _library_has_memories(app: FastAPI, user_id: str = DEFAULT_USER_ID) -> bool:
     """Any active memory at all. Asked only after an empty memory search."""
     try:
         client = await _sdk_client_handle(app).client()
         raw = await asyncio.to_thread(
             client.list_memories,
-            user_id="local",
+            user_id=user_id,
             statuses=["active"],
             limit=1,
             offset=0,
@@ -4499,13 +4860,14 @@ async def _search_sdk_raw(
     *,
     limit: int,
     sources: frozenset[str] | None,
+    user_id: str = DEFAULT_USER_ID,
 ) -> tuple[HySdkRawHit, ...]:
     """The imported conversations nearest the query: the SDK raw layer."""
     client = await _sdk_client_handle(app).client()
     raw = await asyncio.to_thread(
         client.search,
         query,
-        user_ids=["local"],
+        user_ids=[user_id],
         agent_ids=[],
         include_sources=sorted(sources) if sources else None,
         limit=limit,
@@ -4523,9 +4885,11 @@ async def _search_sdk_raw(
 def _sdk_client_handle(app: FastAPI) -> SdkClientHandle:
     handle = cast(SdkClientHandle | None, app.state.sdk_client_handle)
     if handle is None:
-        handle = SdkClientHandle(
-            profile=builtin_retrieval_snapshot(),
-            api_key=None,
+        # Reads open the embedding space writes fill: the active profile's,
+        # the built-in one only when none is active (#242).
+        handle = ActiveProfileReadHandle(
+            profiles=_model_profile_store(app),
+            secrets=_secret_store(app),
             data_dir=cast(Settings, app.state.settings).data_dir,
         )
         app.state.sdk_client_handle = handle
@@ -4608,6 +4972,7 @@ async def _library_search_page(
     limit: int,
     window_id: str | None,
     scene: str = "all",
+    user_id: str = DEFAULT_USER_ID,
 ) -> HySdkMemoryPage:
     """One page of a keyword search, cut from a cached result window.
 
@@ -4619,7 +4984,9 @@ async def _library_search_page(
     SDK so edits and deletes show. The whole library is never listed in Core.
     """
     windows = _library_search_windows(app)
-    key = window_key(query, source, statuses, scene)
+    # The user is part of the window's identity: one user's `window_id` must
+    # never cut a page from another user's matches.
+    key = window_key(query, source, statuses, scene, user_id)
     window = windows.get(window_id, key) if window_id else None
     window_reset = window_id is not None and window is None
     if window is None:
@@ -4629,7 +4996,7 @@ async def _library_search_page(
             query,
             scene="all",
             rerank=False,
-            user_ids=["local"],
+            user_ids=[user_id],
             agent_ids=[],
             include_sources=[source] if source else None,
             limit=fetch,
@@ -4665,7 +5032,7 @@ async def _library_search_page(
         except HySdkReadError:
             skipped += 1
             continue
-        if record.status == "active":
+        if record.status == "active" and owns(record.user_id, user_id):
             memories.append(record)
     _log_skipped_sdk_memories(skipped)
     return HySdkMemoryPage(
@@ -4722,8 +5089,10 @@ def _source_writes_on(app: FastAPI, source_id: str) -> bool:
     forever with attempts=0 while later jobs ran. Intake, claim and execute
     all ask this one question.
     """
-    if source_id == "one-memory-manual":
-        receipt = _grant_store(app).receipt(user_id="local", source_id=source_id)
+    if split_lane(source_id)[1] == "one-memory-manual":
+        # One switch for hand-added memories, whoever adds them: it is a
+        # management setting, and management stays global.
+        receipt = _grant_store(app).receipt(user_id="local", source_id="one-memory-manual")
         return receipt is None or receipt.revoked_at is None
     return _source_processing_enabled(app, source_id)
 
@@ -4757,6 +5126,7 @@ def _history_import_gate_released(app: FastAPI) -> bool:
         job
         for job in jobs.list_jobs()
         if job.operation == "history"
+        and job.user_id == DEFAULT_USER_ID
         and job.source_id in selected
         and (state.started_at is None or job.created_at >= state.started_at)
     ]

memhub/apps/core/src/one_memory/cli.py

@@ -584,6 +584,7 @@ def _sdk_migration_status(options: Sequence[str], stream: TextIO) -> int:
         }
     else:
         from one_memory.hy_runtime_config import HY_MEMORY_NAMESPACE
+        from one_memory.hy_sdk_runtime import builtin_retrieval_snapshot
         from one_memory.sdk_data_plane_migration import (
             MemoryAuthority,
             SdkDataPlaneMigrationStore,
@@ -595,14 +596,14 @@ def _sdk_migration_status(options: Sequence[str], stream: TextIO) -> int:
 
         authority = SdkDataPlaneMigrationStore(database_path).authority()
         if authority is MemoryAuthority.SDK:
-            profile = read_active_profile(database_path)
+            profile = read_active_profile(database_path) or builtin_retrieval_snapshot()
             leftovers = bool(
                 legacy_tables_present(database_path)
                 or abandoned_staging_present(
                     data_dir=settings.data_dir,
                     namespace=HY_MEMORY_NAMESPACE,
                 )
-                or (profile is not None and legacy_vector_collections(settings.data_dir, profile))
+                or legacy_vector_collections(settings.data_dir, profile)
             )
             state = "required" if leftovers else "not_required"
         else:

memhub/apps/core/src/one_memory/context_models.py

@@ -5,6 +5,8 @@ from typing import Annotated, Literal
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
+from one_memory.user_scope import DEFAULT_USER_ID, UserId
+
 ContextKind = Literal["raw", "memory"]
 ContextSearchChannel = Literal["lexical", "semantic"]
 ContextSemanticStatus = Literal["not_searched", "completed", "failed", "timed_out"]
@@ -58,6 +60,8 @@ class SdkContextSearchRequest(ContextSearchRequest):
     limit: int = Field(default=10, ge=1, le=20, strict=True)
     schema_limit: int = Field(default=3, ge=0, le=20, strict=True)
     intention_limit: int = Field(default=1, ge=0, le=20, strict=True)
+    #: Whose memories to search. The App never sends it and reads `local`.
+    user_id: UserId = DEFAULT_USER_ID
 
 
 class ContextMessage(BaseModel):

memhub/apps/core/src/one_memory/context_routes.py

@@ -28,6 +28,7 @@ from one_memory.hy_sdk_types import (
     parse_sdk_search,
 )
 from one_memory.imports.storage import EvidenceStore
+from one_memory.user_scope import owns
 
 CALL_EVENT_RESPONSE_BUDGET_MS = 250
 
@@ -73,7 +74,7 @@ def sdk_context_router(dependencies: Sequence[Depends]) -> APIRouter:
             raw = await asyncio.to_thread(
                 client.search,
                 value.query,
-                user_ids=["local"],
+                user_ids=[value.user_id],
                 agent_ids=[],
                 include_sources=list(authority.raw_sources or ()),
                 limit=value.limit,
@@ -108,7 +109,7 @@ def sdk_context_router(dependencies: Sequence[Depends]) -> APIRouter:
             raw = await asyncio.to_thread(
                 client.search,
                 value.query,
-                user_ids=["local"],
+                user_ids=[value.user_id],
                 agent_ids=[],
                 limit=value.limit,
                 min_score=sdk_relevance_floor(),
@@ -123,7 +124,12 @@ def sdk_context_router(dependencies: Sequence[Depends]) -> APIRouter:
             for hit in hits:
                 record = await asyncio.to_thread(client.get, hit.memory_id)
                 memory = None if record is None else HySdkMemoryRecord.from_sdk(record)
-                if memory is None or memory.status != "active":
+                # `get` takes no user: a hit is kept only if it is the caller's.
+                if (
+                    memory is None
+                    or memory.status != "active"
+                    or not owns(memory.user_id, value.user_id)
+                ):
                     continue
                 items.append(
                     SdkMemoryContextItem(

memhub/apps/core/src/one_memory/hy_runtime_config.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Literal, cast
 
 HY_MEMORY_DISTRIBUTION = "hy-memory"
-HY_MEMORY_VERSION = "2.0.7"
+HY_MEMORY_VERSION = "2.0.9"
 HY_MEMORY_NAMESPACE = "governed-v2"
 DiagnosticLogLevel = Literal["error", "warning", "info", "debug"]
 
@@ -109,11 +109,30 @@ def apply_diagnostic_log_level(level: DiagnosticLogLevel) -> None:
         if any(name == root or name.startswith(f"{root}.") for root in _NOISY_LIBRARY_LOGGERS):
             logging.getLogger(name).setLevel(noisy_level)
 
+    # HY configures its text log once, on the first client, at the level of
+    # that moment. Its file handler must follow later changes too, or a live
+    # switch to debug never reaches hy_memory.log.
+    for handler in logging.getLogger("hy_memory").handlers:
+        if isinstance(handler, logging.FileHandler):
+            handler.setLevel(selected)
+
     os.environ["MEMORY_LOG_LEVEL"] = logging.getLevelName(selected)
-    os.environ["MEMORY_PIPELINE_TRACE_ENABLED"] = "true" if level == "debug" else "false"
+    _apply_hy_pipeline_policy()
     os.environ["MEMORY_LOG_LLM_CONTENT"] = "true" if level == "debug" else "false"
 
 
+def _apply_hy_pipeline_policy() -> None:
+    """Keep HY's per-step pipeline log and trace off at every level.
+
+    Nothing in MemHub reads them: Core's own diagnostics carry the step
+    timing, and the JSONL/SQLite copies only grew on disk. With both off
+    the SDK skips the per-step bookkeeping altogether.
+    """
+
+    os.environ["MEMORY_PIPELINE_LOG_ENABLED"] = "false"
+    os.environ["MEMORY_PIPELINE_TRACE_ENABLED"] = "false"
+
+
 def hy_memory_version() -> str:
     """Return the installed SDK version, failing if the pinned dist is absent."""
 
@@ -131,7 +150,9 @@ def configure_hy_runtime_environment(data_dir: Path) -> None:
     os.environ["MEMORY_LOG_DIR"] = str(log_dir)
     level = diagnostic_log_level(data_dir)
     os.environ["MEMORY_LOG_LEVEL"] = level.upper()
-    os.environ["MEMORY_PIPELINE_TRACE_ENABLED"] = "true" if level == "debug" else "false"
+    _apply_hy_pipeline_policy()
+    # Still meaningful with the pipeline log off: it decides whether HY's
+    # DEBUG lines in hy_memory.log carry full model prompts and responses.
     os.environ["MEMORY_LOG_LLM_CONTENT"] = "true" if level == "debug" else "false"
     os.environ["MEMORY_MEMORY_OPERATIONS_ENABLED"] = "false"
     os.environ["ANONYMIZED_TELEMETRY"] = "False"

memhub/apps/core/src/one_memory/hy_sdk_migration.py

@@ -497,7 +497,7 @@ def _ensure_coding_schema(path: Path) -> None:
         CodingMemoryStore,
     )
 
-    # Relies on the pinned SDK's internals (hy-memory==2.0.7 is pinned exactly).
+    # Relies on the pinned SDK's internals (hy-memory==2.0.9 is pinned exactly).
     store = CodingMemoryStore.__new__(CodingMemoryStore)
     store._db_path = str(path)
     store._conn = None

memhub/apps/core/src/one_memory/hy_sdk_runtime.py

@@ -36,6 +36,7 @@ from one_memory.hy_graph_admin import (
 )
 from one_memory.hy_sdk_types import HySdkRuntimeError
 from one_memory.local_embedding import LocalEmbedder
+from one_memory.log_file import confine_hy_sdk_logging
 from one_memory.model_profiles import (
     ModelProfileSnapshot,
     ProviderKind,
@@ -66,6 +67,16 @@ _STORE_GATE = threading.Condition()
 _OFFLINE_STORES: set[Path] = set()
 _OPENING: dict[Path, int] = {}
 
+# One client constructs at a time per home, its first-time store setup
+# included. The constructor opens Chroma's `PersistentClient`, and two first
+# opens on one directory race over that same unlocked System cache. On a
+# clean install the write drain's client and a UI read client started in the
+# same second; neither reached `VectorStore ready`, and the first write job
+# was lost as unknown. Taken inside `acquire_client`, after the offline gate
+# and never while `_STORE_GATE` is held, so it cannot deadlock with
+# `hold_stores_offline`, which refuses while `_OPENING` counts a client.
+_CONSTRUCTING: dict[Path, threading.Lock] = {}
+
 
 class LocalOnnxEmbeddingService:
     """Public ``EmbeddingService`` implementation backed by MemHub's ONNX model."""
@@ -206,6 +217,33 @@ def builtin_retrieval_snapshot() -> ModelProfileSnapshot:
     )
 
 
+def retrieval_view(profile: ModelProfileSnapshot) -> ModelProfileSnapshot:
+    """The read side of `profile`: its embedding space, and no generation.
+
+    Reads must open the collection writes fill (#242), and the collection is
+    named by the embedding only. Generation stays the built-in placeholder, so
+    a read never needs the generation model. A remote embedding still needs
+    the profile's API key, which `build_sdk_config` uses as the embedding key.
+    """
+    provider = profile.embedding_provider_kind or profile.provider_kind
+    endpoint: str | None = None
+    if provider is not ProviderKind.LOCAL_ONNX:
+        endpoint = profile.embedding_base_url
+        if not endpoint:
+            raise HySdkRuntimeError("hy_sdk_model_endpoint_missing")
+    return builtin_retrieval_snapshot().model_copy(
+        update={
+            "profile_id": profile.profile_id,
+            "revision": profile.revision,
+            "embedding_provider_kind": provider,
+            "embedding_model": profile.embedding_model,
+            "embedding_base_url": endpoint,
+            "embedding_dimensions": profile.embedding_dimensions,
+            "has_api_key": profile.has_api_key,
+        }
+    )
+
+
 def sdk_relevance_floor() -> float:
     raw = os.environ.get("ONE_MEMORY_HY_RELEVANCE_FLOOR", "").strip()
     if not raw:
@@ -238,10 +276,8 @@ def build_sdk_config(
         embedding_key = None
         dimensions = profile.embedding_dimensions or BUILTIN_EMBEDDING_DIMENSIONS
     else:
-        embedding_endpoint = _openai_endpoint(
-            embedding_provider,
-            profile.embedding_base_url or profile.base_url,
-        )
+        # Never the generation endpoint: the collection name hashes this one.
+        embedding_endpoint = _openai_endpoint(embedding_provider, profile.embedding_base_url)
         embedding_key = "ollama" if embedding_provider is ProviderKind.OLLAMA else api_key
         if embedding_provider is ProviderKind.OPENAI_COMPATIBLE and not embedding_key:
             raise HySdkRuntimeError("hy_sdk_embedding_api_key_missing")
@@ -381,16 +417,23 @@ def _acquire_client(
     embedding_service: LocalOnnxEmbeddingService | None = None
     if (profile.embedding_provider_kind or profile.provider_kind) is ProviderKind.LOCAL_ONNX:
         embedding_service = LocalOnnxEmbeddingService()
+    with _STORE_GATE:
+        constructing = _CONSTRUCTING.setdefault(key, threading.Lock())
     try:
-        client = HyMemoryClient(
-            config=config,
-            mode="ultra" if graph_store_enabled() else "pro",
-            runtime=runtime,
-            embedding_service=embedding_service,
-        )
+        with constructing:
+            client = HyMemoryClient(
+                config=config,
+                mode="ultra" if graph_store_enabled() else "pro",
+                runtime=runtime,
+                embedding_service=embedding_service,
+            )
     except BaseException:
         _release_runtime(key)
         raise
+    finally:
+        # The constructor's first step configures HY's text log (once per
+        # process), so by here it exists whether or not construction succeeded.
+        confine_hy_sdk_logging()
     return ClientLease(client, key)
 
 
@@ -449,7 +492,7 @@ def vector_collection_bases(profile: ModelProfileSnapshot) -> tuple[str, tuple[s
         endpoint, dimensions = None, profile.embedding_dimensions or BUILTIN_EMBEDDING_DIMENSIONS
         legacy_endpoint = "local-onnx"
     else:
-        endpoint = _openai_endpoint(provider, profile.embedding_base_url or profile.base_url)
+        endpoint = _openai_endpoint(provider, profile.embedding_base_url)
         dimensions = profile.embedding_dimensions
         legacy_endpoint = endpoint
     legacy_model = profile.embedding_model or "bge-small-zh-v1.5"

memhub/apps/core/src/one_memory/imports/adapters.py

@@ -31,6 +31,16 @@ class ScanIssueCode(StrEnum):
     #: import it. Named for the reason, so a reader can tell a setting from
     #: a record the parser could not use.
     SUBAGENT_TRACE_DISABLED = "subagent_trace_disabled"
+    #: A host's own notice wearing the user's role — Hermes posts a finished
+    #: background process, and its gateway marks the post as not written by a
+    #: human. Nothing in it is the person's, so it never reaches extraction.
+    INJECTED_MACHINE_NOTICE = "injected_machine_notice"
+    #: The host could not transcribe a voice message and left a placeholder
+    #: naming the audio file. The person did speak, but the placeholder holds
+    #: only a path, which an extractor would otherwise read as a fact.
+    VOICE_PLACEHOLDER = "voice_placeholder"
+    #: A health check such as "Reply with exactly: PONG": no one's words.
+    PROBE = "probe"
     SOURCE_BUSY = "source_busy"
     UNSUPPORTED_SCHEMA = "unsupported_schema"
     BUDGET_EXCEEDED = "budget_exceeded"

memhub/apps/core/src/one_memory/imports/discovery.py

@@ -27,6 +27,7 @@ def discovered_off_loop(
     *,
     suffixes: frozenset[str],
     max_targets: int,
+    excluded_top_directories: frozenset[str] = frozenset(),
 ) -> AsyncIterator[SourceFileDiscoveryEvent]:
     """The same walk, for callers that have an event loop to keep free.
 
@@ -41,6 +42,7 @@ def discovered_off_loop(
             grant,
             suffixes=suffixes,
             max_targets=max_targets,
+            excluded_top_directories=excluded_top_directories,
         ),
         scope_key=grant.source_id,
     )
@@ -51,12 +53,15 @@ def discover_source_files(
     *,
     suffixes: frozenset[str],
     max_targets: int,
+    excluded_top_directories: frozenset[str] = frozenset(),
 ) -> Iterator[SourceFileDiscoveryEvent]:
     """Metadata only: one lstat per candidate, no open and no per-file grant lookup.
 
     The grant and root identity are checked once before the walk. Each listed
     file keeps the grant's check, which runs again when that file is opened;
     the open itself refuses symlinks and any inode other than the one listed.
+    `excluded_top_directories` are directories directly under the root that
+    are never entered, such as another user's Hermes profiles.
     """
     grant.check_root()
     inspected = 0
@@ -64,8 +69,12 @@ def discover_source_files(
         grant.root,
         followlinks=False,
     ):
+        at_root = Path(directory) == grant.root
         child_directories[:] = sorted(
-            child for child in child_directories if not (Path(directory) / child).is_symlink()
+            child
+            for child in child_directories
+            if not (Path(directory) / child).is_symlink()
+            and not (at_root and child in excluded_top_directories)
         )
         for filename in sorted(filenames):
             if Path(filename).suffix.lower() not in suffixes:

memhub/apps/core/src/one_memory/imports/grants.py

@@ -252,6 +252,18 @@ class SourceGrantStore:
             ).fetchone()
         return self._to_receipt(row) if row else None
 
+    def grants(self) -> tuple[tuple[SourceGrantReceipt, str], ...]:
+        """Every grant of every user, with its granted root path.
+
+        One source may hold several grants, one per `(user_id, source_id)`:
+        a Hermes root for `local` and a Hermes profile for another user.
+        """
+        with self._connect() as connection:
+            rows = connection.execute(
+                "SELECT * FROM source_grants ORDER BY source_id, user_id"
+            ).fetchall()
+        return tuple((self._to_receipt(row), str(row["requested_path"])) for row in rows)
+
     def require_receipt(self, *, user_id: str, source_id: str) -> SourceGrantReceipt:
         receipt = self.receipt(user_id=user_id, source_id=source_id)
         if receipt is None:

memhub/apps/core/src/one_memory/imports/live_sync.py

@@ -28,6 +28,7 @@ from one_memory.imports.adapters import (
 )
 from one_memory.imports.jobs import ImportJob, ImportJobStore, ImportStatus
 from one_memory.imports.supervisor import ImportSupervisor
+from one_memory.user_scope import DEFAULT_USER_ID, lane_key, split_lane
 
 #: How long an automatic retry will wait for a wedged worker to notice cancel.
 ABANDON_TIMEOUT_SECONDS = 5.0
@@ -64,7 +65,12 @@ class LiveSyncHealth(BaseModel):
 
 
 class PollingLiveSyncSupervisor:
-    """Near-live sync that reuses each adapter's persisted incremental cursor."""
+    """Near-live sync that reuses each adapter's persisted incremental cursor.
+
+    A "source" here is a lane key (`user_scope.lane_key`): the bare source id
+    for `local`, `source@user` for another user's grant. Cursors, jobs and
+    locks are therefore per `(user_id, source_id)`.
+    """
 
     def __init__(
         self,
@@ -92,8 +98,22 @@ class PollingLiveSyncSupervisor:
         }
         self._locks = {source_id: asyncio.Lock() for source_id in self.source_ids}
         self._task: asyncio.Task[None] | None = None
+        self._group: asyncio.TaskGroup | None = None
         self._observers: set[asyncio.Task[None]] = set()
 
+    def ensure_source(self, source_id: str) -> None:
+        """Follow a lane granted after start, such as a new Hermes profile."""
+        if source_id in self._locks:
+            return
+        self.source_ids = (*self.source_ids, source_id)
+        self._health.setdefault(
+            source_id,
+            LiveSyncHealth(source_id=source_id, mode=self.mode, state=LiveSyncState.IDLE),
+        )
+        self._locks[source_id] = asyncio.Lock()
+        if self._group is not None:
+            self._group.create_task(self._poll_source(source_id))
+
     def _set_health(self, source_id: str, value: LiveSyncHealth) -> None:
         previous = self._health.get(source_id)
         self._health[source_id] = value
@@ -152,7 +172,12 @@ class PollingLiveSyncSupervisor:
         self._watched_sources = frozenset(source_ids)
 
     def all_health(self) -> tuple[LiveSyncHealth, ...]:
-        return tuple(self.health(source_id) for source_id in self.source_ids)
+        """`local`'s lanes only: what the App has always been shown."""
+        return tuple(
+            self.health(source_id)
+            for source_id in self.source_ids
+            if split_lane(source_id)[0] == DEFAULT_USER_ID
+        )
 
     async def initialize_source(
         self, source_id: str, *, baseline_missing_files: bool = True
@@ -164,11 +189,12 @@ class PollingLiveSyncSupervisor:
         baselines = (
             await adapter.live_baseline() if isinstance(adapter, _LiveBaselineAdapter) else {}
         )
+        user_id, bare_source_id = split_lane(source_id)
         await in_the_background(
             partial(
                 self.job_store.ensure_live_cursors,
-                user_id="local",
-                source_id=source_id,
+                user_id=user_id,
+                source_id=bare_source_id,
                 baselines=baselines,
                 baseline_missing_files=baseline_missing_files,
             )
@@ -228,7 +254,7 @@ class PollingLiveSyncSupervisor:
                 (
                     job
                     for job in reversed(source_jobs)
-                    if job.source_id == source_id
+                    if lane_key(job.user_id, job.source_id) == source_id
                     and job.operation == "sync"
                     and job.status
                     in {
@@ -277,13 +303,13 @@ class PollingLiveSyncSupervisor:
             competing = [
                 job
                 for job in source_jobs
-                if job.source_id == source_id
+                if lane_key(job.user_id, job.source_id) == source_id
                 and job.operation != "sync"
                 and job.status
                 in {ImportStatus.PENDING, ImportStatus.RUNNING, ImportStatus.INTERRUPTED}
             ]
             bounded_history_incomplete = any(
-                job.source_id == source_id
+                lane_key(job.user_id, job.source_id) == source_id
                 and job.operation == "history"
                 and job.history_after is not None
                 and job.status is not ImportStatus.COMPLETED
@@ -379,11 +405,12 @@ class PollingLiveSyncSupervisor:
                 await close()
 
     async def _live_cursors(self, source_id: str, adapter: object) -> dict[str, SourceCursor]:
+        user_id, bare_source_id = split_lane(source_id)
         cursors = await in_the_background(
             partial(
                 self.job_store.get_source_cursors,
-                user_id="local",
-                source_id=source_id,
+                user_id=user_id,
+                source_id=bare_source_id,
                 operation="sync",
             )
         )
@@ -395,8 +422,8 @@ class PollingLiveSyncSupervisor:
         return await in_the_background(
             partial(
                 self.job_store.ensure_live_cursors,
-                user_id="local",
-                source_id=source_id,
+                user_id=user_id,
+                source_id=bare_source_id,
                 baselines=baselines,
             )
         )
@@ -520,9 +547,13 @@ class PollingLiveSyncSupervisor:
     async def _run(self) -> None:
         # A source owns its cadence; one large catch-up cannot delay every
         # other source. The group keeps shutdown responsible for every poller.
-        async with asyncio.TaskGroup() as group:
-            for source_id in self.source_ids:
-                group.create_task(self._poll_source(source_id))
+        try:
+            async with asyncio.TaskGroup() as group:
+                self._group = group
+                for source_id in self.source_ids:
+                    group.create_task(self._poll_source(source_id))
+        finally:
+            self._group = None
 
     async def _poll_source(self, source_id: str) -> None:
         while True:

memhub/apps/core/src/one_memory/imports/runner.py

@@ -3,7 +3,7 @@ import logging
 import math
 import sqlite3
 from collections import Counter
-from collections.abc import Callable
+from collections.abc import AsyncIterator, Callable
 from contextlib import suppress
 from contextvars import ContextVar
 from dataclasses import dataclass, field
@@ -227,14 +227,17 @@ class ImportRunner:
         heartbeat = asyncio.create_task(self._keep_alive(job_id=job_id, runner_token=runner_token))
         pending = _PendingSkips()
         writes = _PendingWrites()
-        stream = adapter.scan(
-            ScanOptions(
-                cursors=cursors,
-                reuse_listing=(
-                    job.operation == "history"
-                    or (job.operation == "sync" and job.source_id == "workbuddy")
-                ),
-            )
+        stream = _owned_by(
+            adapter.scan(
+                ScanOptions(
+                    cursors=cursors,
+                    reuse_listing=(
+                        job.operation == "history"
+                        or (job.operation == "sync" and job.source_id == "workbuddy")
+                    ),
+                )
+            ),
+            job.user_id,
         )
         slice_cursors = dict(cursors)
         next_event: asyncio.Future[ScanEvent] | None = None
@@ -924,3 +927,30 @@ async def _settled_work[T](
         with suppress(asyncio.CancelledError, Exception):
             task.result()
         raise
+
+
+def _owned_by(stream: AsyncIterator[ScanEvent], user_id: str) -> AsyncIterator[ScanEvent]:
+    """Stamp every scanned record with the user whose root is being read.
+
+    Adapters know nothing of users and emit `local`. Which user a record
+    belongs to is decided by the grant the job reads (a Hermes profile's
+    `state.db` is that profile's user), so the job's user is the record's.
+    `local` passes the stream through untouched.
+    """
+    if user_id == "local":
+        return stream
+    return _restamped(stream, user_id)
+
+
+async def _restamped(stream: AsyncIterator[ScanEvent], user_id: str) -> AsyncIterator[ScanEvent]:
+    try:
+        async for event in stream:
+            if isinstance(event, ScannedEvidence) and event.evidence.user_id != user_id:
+                event = event.model_copy(
+                    update={"evidence": event.evidence.model_copy(update={"user_id": user_id})}
+                )
+            yield event
+    finally:
+        close = getattr(stream, "aclose", None)
+        if close is not None:
+            await close()

memhub/apps/core/src/one_memory/imports/sources/hermes.py

@@ -1,4 +1,5 @@
 import json
+import re
 import sqlite3
 from collections.abc import AsyncIterator, Iterator
 from functools import partial
@@ -87,6 +88,7 @@ class HermesSourceAdapter:
             self.grant,
             suffixes=frozenset({".jsonl", ".db"}),
             max_targets=10_000,
+            excluded_top_directories=frozenset({HERMES_PROFILES_DIRECTORY}),
         ):
             if isinstance(item, AuthorizedSourceFile) and _is_hermes_target(
                 item.relative_path.as_posix()
@@ -100,6 +102,7 @@ class HermesSourceAdapter:
             self.grant,
             suffixes=frozenset({".jsonl", ".db"}),
             max_targets=options.max_scan_targets or 100_000,
+            excluded_top_directories=frozenset({HERMES_PROFILES_DIRECTORY}),
         ):
             yield ScanProgressEvent(
                 phase=ScanPhase.DISCOVER,
@@ -214,7 +217,11 @@ def parse_hermes_rollout_record(
         message.get("content"),
         allowed_block_types=frozenset({"text", "input_text", "output_text"}),
     )
-    text = strip_injected_memory(text)
+    text = strip_injected_memory(text or "")
+    if role == "user":
+        text, injected = gateway_user_text(text)
+        if injected is not None:
+            return ParsedSkip(reason_code=injected, conversation_id=conversation_id)
     if not text:
         return ParsedSkip(
             reason_code=ScanIssueCode.NO_TEXT,
@@ -242,8 +249,17 @@ def parse_hermes_rollout_record(
     )
 
 
+#: Hermes keeps each extra profile under `<root>/profiles/<name>/`, with its
+#: own `state.db` and sessions. A profile is another person's history: it is
+#: read only through its own grant (its own MemHub user), never as part of the
+#: root above it. Hermes' own export skips this directory for the same reason.
+HERMES_PROFILES_DIRECTORY = "profiles"
+
+
 def _is_hermes_target(relative_path: str) -> bool:
     path = PurePosixPath(relative_path)
+    if path.parts and path.parts[0] == HERMES_PROFILES_DIRECTORY:
+        return False
     return path.name == "state.db" or (path.suffix == ".jsonl" and "sessions" in path.parts)
 
 
@@ -389,6 +405,15 @@ def _read_state_db(
             # `tool` rows after it hold only what came back.
             calls = _tool_calls_text(row["tool_calls"]) if role == "assistant" else None
             content = strip_injected_memory(str(row["content"] or ""))
+            if role == "user":
+                content, injected = gateway_user_text(content)
+                if injected is not None:
+                    yield ScanSkip(
+                        cursor=cursor,
+                        conversation_id=str(row["session_id"]),
+                        reason_code=injected,
+                    )
+                    continue
             has_text = bool(content.strip())
             if role not in {"user", "assistant"} or (not has_text and calls is None):
                 yield ScanSkip(
@@ -439,6 +464,69 @@ def _read_state_db(
 _PERSON_SESSION_SOURCES = frozenset({"cli", "tui", "webui", "desktop"})
 
 
+#: What the Hermes gateway writes into a `user` row on its own behalf. Every
+#: one of these wears the `user` role, so only the text can tell them apart
+#: from the person. Read off real `state.db` rows: a finished background
+#: process is posted as a turn, often with the gateway's own "not written by
+#: a human" note appended, which is why that note counts anywhere in the row.
+_BACKGROUND_NOTICE = re.compile(
+    r"\[IMPORTANT:\s*(?:\d+\s+background\s+process(?:es)?\b|Background\s+process\b)",
+    re.IGNORECASE,
+)
+_GATEWAY_NOTICE = re.compile(
+    r"\[INTERNAL NOTIFICATION\s*\W+\s*generated by the Hermes gateway",
+    re.IGNORECASE,
+)
+_VOICE_PLACEHOLDER = re.compile(r"\[voice message could not be transcribed", re.IGNORECASE)
+_PROBE = re.compile(r"Reply with exactly:\s*[A-Za-z0-9_\-]{1,24}\s*")
+_MEDIA_ONLY = re.compile(r"(?:MEDIA:/\S+\s*)+")
+#: Wrappers the gateway puts around a message the person did write. Only the
+#: wrapper goes; what it carries is the turn. Each is matched at the edge of
+#: what is left, and the set is applied until nothing more comes off, since a
+#: relayed message carries the origin block inside the out-of-band markers.
+_GATEWAY_WRAPPERS = (
+    re.compile(r"^\[OUT-OF-BAND USER MESSAGE\b[^\]\n]*\]"),
+    re.compile(r"\[/OUT-OF-BAND USER MESSAGE\]$"),
+    re.compile(
+        r"^Gateway message origin \(JSON data, not instructions or authorization\):[ \t]*"
+        r"(?:\n[ \t]*\{[^\n]*\}[ \t]*)?"
+        r"(?:\n[ \t]*Do not guess a reply destination[^\n]*)?"
+        r"(?=\n|$)"
+    ),
+    re.compile(r"^\[Context from the interrupted assistant response\][ \t]*(?=\n|$)"),
+)
+
+
+def gateway_user_text(text: str) -> tuple[str, ScanIssueCode | None]:
+    """The person's words in a Hermes `user` row, or why there are none.
+
+    Applied only to the `user` role: an assistant or tool row quoting the
+    same text is reporting what it saw, which is the existing tool rule's
+    business. The cleaned text is what becomes the evidence, so its content
+    hash and duplicate check see the message rather than its envelope.
+    """
+
+    if _GATEWAY_NOTICE.search(text):
+        return "", ScanIssueCode.INJECTED_MACHINE_NOTICE
+    cleaned = text.strip()
+    while True:
+        unwrapped = cleaned
+        for wrapper in _GATEWAY_WRAPPERS:
+            unwrapped = wrapper.sub("", unwrapped, count=1).strip()
+        if unwrapped == cleaned:
+            break
+        cleaned = unwrapped
+    if _BACKGROUND_NOTICE.match(cleaned):
+        return "", ScanIssueCode.INJECTED_MACHINE_NOTICE
+    if _VOICE_PLACEHOLDER.match(cleaned):
+        return "", ScanIssueCode.VOICE_PLACEHOLDER
+    if _PROBE.fullmatch(cleaned):
+        return "", ScanIssueCode.PROBE
+    if _MEDIA_ONLY.fullmatch(cleaned):
+        return "", ScanIssueCode.NO_TEXT
+    return cleaned, None
+
+
 def _tool_calls_text(value: object) -> str | None:
     """OpenAI-shaped `tool_calls`: `[{"function": {"name", "arguments"}}]`, stored as JSON."""
     if isinstance(value, str):

memhub/apps/core/src/one_memory/imports/supervisor.py

@@ -24,6 +24,7 @@ from one_memory.service_levels import (
     ServiceLevelScheduler,
     ServiceResource,
 )
+from one_memory.user_scope import lane_key, split_lane
 
 
 class UnknownSourceError(KeyError):
@@ -82,36 +83,45 @@ class ImportSupervisor:
         self._tasks: dict[str, asyncio.Task[None]] = {}
         self._drains: dict[str, asyncio.Task[None]] = {}
 
-    def register_adapter(self, adapter: SourceAdapter) -> None:
-        self.adapters[adapter.descriptor.source_id] = adapter
+    def register_adapter(self, adapter: SourceAdapter, *, user_id: str = "local") -> None:
+        """Adapters are keyed by lane: the source id for `local`, `source@user`
+        for another user's grant of the same source."""
+        self.adapters[lane_key(user_id, adapter.descriptor.source_id)] = adapter
 
     def unregister_adapter(self, source_id: str) -> None:
         self.adapters.pop(source_id, None)
 
+    @staticmethod
+    def lane_of(job: ImportJob) -> str:
+        return lane_key(job.user_id, job.source_id)
+
     def active_job_ids(self) -> frozenset[str]:
         return frozenset(job_id for job_id, task in self._tasks.items() if not task.done())
 
     def create_job(
         self, source_id: str, *, operation: Literal["history", "sync"] = "history"
     ) -> ImportJob:
+        """`source_id` is a lane key: another user's lane creates that user's job."""
         if self.source_enabled is not None and not self.source_enabled(source_id):
             raise SourceAccessError(SourceAccessErrorCode.GRANT_REQUIRED)
-        return self.job_store.create(user_id="local", source_id=source_id, operation=operation)
+        user_id, bare_source_id = split_lane(source_id)
+        return self.job_store.create(user_id=user_id, source_id=bare_source_id, operation=operation)
 
     def enqueue(self, job_id: str) -> ImportJob:
         if job_id in self._drains:
             raise InvalidJobTransitionError("import_cleanup_in_progress")
         job = self.job_store.require(job_id)
-        if job.source_id not in self.adapters:
-            raise UnknownSourceError(job.source_id)
-        if self.source_enabled is not None and not self.source_enabled(job.source_id):
+        lane = self.lane_of(job)
+        if lane not in self.adapters:
+            raise UnknownSourceError(lane)
+        if self.source_enabled is not None and not self.source_enabled(lane):
             return job
         existing = self._tasks.get(job_id)
         if existing is None or existing.done():
             self._tasks[job_id] = asyncio.create_task(
                 self._execute(
                     job_id,
-                    source_id=job.source_id,
+                    source_id=lane,
                     operation=job.operation,
                 )
             )
@@ -130,8 +140,10 @@ class ImportSupervisor:
         # pending history. Each resumed runner will yield after one bounded slice.
         for status in (ImportStatus.INTERRUPTED, ImportStatus.PENDING):
             for job in self.job_store.list_jobs(status=status):
-                if job.source_id in self.adapters:
-                    if self.source_enabled is not None and not self.source_enabled(job.source_id):
+                if self.lane_of(job) in self.adapters:
+                    if self.source_enabled is not None and not self.source_enabled(
+                        self.lane_of(job)
+                    ):
                         continue
                     if job.status is not ImportStatus.PENDING:
                         self.job_store.queue_for_resume(job.job_id)
@@ -227,7 +239,7 @@ class ImportSupervisor:
                     }:
                         return
                     if self.source_enabled is not None and not await in_the_background(
-                        self.source_enabled, job.source_id
+                        self.source_enabled, self.lane_of(job)
                     ):
                         return
                     runner = ImportRunner(
@@ -238,7 +250,7 @@ class ImportSupervisor:
                         sdk_queue=self.sdk_queue,
                         sdk_authority=self.sdk_authority,
                     )
-                    adapter = self.adapters[job.source_id]
+                    adapter = self.adapters[self.lane_of(job)]
                     if self.prepare_adapter is not None:
                         adapter = await self.prepare_adapter(job, adapter)
 
@@ -273,7 +285,7 @@ class ImportSupervisor:
                 and retry_attempt < self.max_history_retries
                 and (
                     self.source_enabled is None
-                    or await in_the_background(self.source_enabled, current.source_id)
+                    or await in_the_background(self.source_enabled, self.lane_of(current))
                 )
             ):
                 delay = self.retry_base_seconds * (2**retry_attempt)

memhub/apps/core/src/one_memory/library_search_window.py

@@ -7,9 +7,9 @@ between pages. The matches are kept here under an opaque ``window_id`` that
 the client passes back with the next offset.
 
 A window is bound to the filters it was searched with (query, source,
-statuses, scene). It expires after ``ttl_seconds`` without being read, and the
-store keeps at most ``max_windows`` windows, dropping the least recently read
-first.
+statuses, scene) and to the user whose library it searched. It expires after
+``ttl_seconds`` without being read, and the store keeps at most
+``max_windows`` windows, dropping the least recently read first.
 Only memory identities are kept, never content: each page is read fresh from
 the SDK, so an edit or a delete shows on the next page read.
 """
@@ -28,13 +28,17 @@ from one_memory.hy_sdk_types import LibraryHit
 DEFAULT_WINDOW_TTL_SECONDS = 300.0
 DEFAULT_MAX_WINDOWS = 32
 
-WindowKey = tuple[str, str | None, tuple[str, ...], str]
+WindowKey = tuple[str, str | None, tuple[str, ...], str, str]
 
 
 def window_key(
-    query: str, source: str | None, statuses: list[str], scene: str = "all"
+    query: str,
+    source: str | None,
+    statuses: list[str],
+    scene: str = "all",
+    user_id: str = "local",
 ) -> WindowKey:
-    return (query, source, tuple(sorted(set(statuses))), scene)
+    return (query, source, tuple(sorted(set(statuses))), scene, user_id)
 
 
 @dataclass(frozen=True)

memhub/apps/core/src/one_memory/log_file.py

@@ -20,8 +20,11 @@ def start_logging_to_file(data_dir: Path) -> Path:
     nowhere. That includes the loop watchdog: the one report that names what
     stalled the app was unreadable in exactly the situation it exists for.
 
-    The active diagnostic collection level controls Core, HY SDK, and provider
-    client records. Uvicorn keeps its request log on its own non-propagating
+    The active diagnostic collection level controls Core and provider client
+    records. The HY SDK keeps its own text log, hy_memory.log under the SDK's
+    log directory, and stops propagating here once its first client is built;
+    `confine_hy_sdk_logging` then forwards only its warnings and errors to
+    this file. Uvicorn keeps its request log on its own non-propagating
     loggers.
     """
     destination = log_path(data_dir)
@@ -49,3 +52,53 @@ def start_logging_to_file(data_dir: Path) -> Path:
     if root.level > logging.INFO or root.level == logging.NOTSET:
         root.setLevel(logging.INFO)
     return destination
+
+
+HY_SDK_LOGGER = "hy_memory"
+
+
+class _CoreLogForwarder(logging.Handler):
+    """Hands HY warnings to Core's own core.log handler, rotation and format."""
+
+    def __init__(self, target: logging.Handler) -> None:
+        super().__init__(level=logging.WARNING)
+        self.target = target
+
+    def emit(self, record: logging.LogRecord) -> None:
+        self.target.handle(record)
+
+
+def confine_hy_sdk_logging() -> None:
+    """Keep HY's text log in hy_memory.log, with only its problems in core.log.
+
+    HY's first client sets up hy_memory.log plus a stdout and a stderr stream
+    on the "hy_memory" logger, and stops it propagating to the root. Under
+    launchd those streams are service.log and service-error.log, so every SDK
+    line was written twice, and none reached core.log. Drop the streams and
+    forward WARNING and above to core.log, which the Debug panel reads; the
+    SDK keeps conversation text out of those levels.
+
+    Idempotent. Does nothing until HY has configured its logger, because a
+    propagating logger already reaches core.log through the root.
+    """
+    sdk = logging.getLogger(HY_SDK_LOGGER)
+    if sdk.propagate:
+        return
+    for handler in list(sdk.handlers):
+        if isinstance(handler, logging.StreamHandler) and not isinstance(
+            handler, logging.FileHandler
+        ):
+            sdk.removeHandler(handler)
+    if any(isinstance(handler, _CoreLogForwarder) for handler in sdk.handlers):
+        return
+    core = next(
+        (
+            handler
+            for handler in logging.getLogger().handlers
+            if isinstance(handler, RotatingFileHandler)
+            and Path(handler.baseFilename).name == "core.log"
+        ),
+        None,
+    )
+    if core is not None:
+        sdk.addHandler(_CoreLogForwarder(core))

memhub/apps/core/src/one_memory/memory_additions.py

@@ -11,10 +11,11 @@ import asyncio
 import sqlite3
 from collections.abc import Sequence
 from datetime import UTC, datetime
+from functools import partial
 from typing import Any, Literal, cast
 from uuid import UUID
 
-from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
+from fastapi import APIRouter, BackgroundTasks, HTTPException, Query, Request
 from fastapi.params import Depends
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
@@ -34,6 +35,7 @@ from one_memory.memory_server.durable_queue import DurableWriteQueue
 from one_memory.memory_server.unified_entry import UnifiedWriteIntake
 from one_memory.memory_tasks import MemoryTaskStatus, MemoryTaskStore
 from one_memory.secrets import SecretStoreUnavailableError
+from one_memory.user_scope import DEFAULT_USER_ID, USER_ID_PATTERN, UserId
 
 SOURCE_ID = "one-memory-manual"
 MemoryAddState = Literal[
@@ -53,6 +55,8 @@ class MemoryAddInput(BaseModel):
     request_id: UUID
     text: str = Field(min_length=1, max_length=12_000)
     scope: Literal["all-apps"]
+    #: Whose memory this is. The App never sends it and writes `local`.
+    user_id: UserId = DEFAULT_USER_ID
 
     @field_validator("text")
     @classmethod
@@ -108,7 +112,11 @@ class MemoryAdditionStore:
 
     def save(self, addition: MemoryAddInput) -> EvidenceRecord:
         now = datetime.now(UTC)
+        if addition.user_id != DEFAULT_USER_ID and not self.sdk_authority:
+            # Legacy authority keeps one person's library only.
+            raise ValueError("memory_add_user_requires_sdk_authority")
         value = EvidenceInput(
+            user_id=addition.user_id,
             source_id=SOURCE_ID,
             conversation_id=f"note:{addition.request_id}",
             message_id=str(addition.request_id),
@@ -200,7 +208,7 @@ class MemoryAdditionStore:
                 )
         return self.require(value.evidence_id)
 
-    def require(self, evidence_id: str) -> EvidenceRecord:
+    def require(self, evidence_id: str, *, user_id: str = DEFAULT_USER_ID) -> EvidenceRecord:
         if self.sdk_authority:
             if self.write_queue is None:
                 raise KeyError(evidence_id)
@@ -219,11 +227,11 @@ class MemoryAdditionStore:
                 (item for item in payload.input_records if item.evidence_id == evidence_id),
                 None,
             )
-            if record is None:
+            if record is None or record.user_id != user_id:
                 raise KeyError(evidence_id)
             return record
         record = self.evidence.get(evidence_id)
-        if record is None or record.user_id != "local" or record.source_id != SOURCE_ID:
+        if record is None or record.user_id != user_id or record.source_id != SOURCE_ID:
             raise KeyError(evidence_id)
         metadata = record.origin_meta.get(EvidenceOrigin.MANUAL_IMPORT)
         if metadata is None or metadata.raw_meta.get("input_mode") != "direct_memory_note":
@@ -237,8 +245,8 @@ class MemoryAdditionStore:
             raise ValueError("memory_add_source_revoked")
         return record
 
-    def receipt(self, evidence_id: str) -> MemoryAddReceipt:
-        record = self.require(evidence_id)
+    def receipt(self, evidence_id: str, *, user_id: str = DEFAULT_USER_ID) -> MemoryAddReceipt:
+        record = self.require(evidence_id, user_id=user_id)
         if self.sdk_authority:
             assert self.write_queue is not None
             with main_database(self.write_queue.database_path).read() as database:
@@ -300,10 +308,15 @@ class MemoryAdditionStore:
             error=error,
         )
 
-    def receipt_for_request(self, request_id: UUID) -> MemoryAddReceipt:
+    def receipt_for_request(
+        self, request_id: UUID, *, user_id: str = DEFAULT_USER_ID
+    ) -> MemoryAddReceipt:
         identity = str(request_id)
         if self.sdk_authority:
+            # The Evidence id carries the user, so another user's request id
+            # names a different note and reads as not found.
             probe = EvidenceInput(
+                user_id=user_id,
                 source_id=SOURCE_ID,
                 conversation_id=f"note:{identity}",
                 message_id=identity,
@@ -316,16 +329,16 @@ class MemoryAdditionStore:
                     )
                 },
             )
-            return self.receipt(probe.evidence_id)
+            return self.receipt(probe.evidence_id, user_id=user_id)
         with main_database(self.evidence.database_path).read() as db:
             row = db.execute(
-                "SELECT evidence_id FROM evidence WHERE user_id='local' AND source_id=? "
+                "SELECT evidence_id FROM evidence WHERE user_id=? AND source_id=? "
                 "AND conversation_id=? AND message_id=?",
-                (SOURCE_ID, f"note:{identity}", identity),
+                (user_id, SOURCE_ID, f"note:{identity}", identity),
             ).fetchone()
         if row is None:
             raise KeyError(identity)
-        return self.receipt(str(row[0]))
+        return self.receipt(str(row[0]), user_id=user_id)
 
 
 def memory_add_router(dependencies: Sequence[Depends]) -> APIRouter:
@@ -376,14 +389,20 @@ def memory_add_router(dependencies: Sequence[Depends]) -> APIRouter:
             record = await asyncio.to_thread(additions.save, addition)
         except ValueError as error:
             raise HTTPException(409, str(error)) from error
-        saved = await asyncio.to_thread(additions.receipt, record.evidence_id)
+        saved = await asyncio.to_thread(
+            partial(additions.receipt, record.evidence_id, user_id=addition.user_id)
+        )
         background.add_task(schedule, additions, record)
         return saved
 
     @router.get("/additions/{request_id}", response_model=MemoryAddReceipt)
-    def memory_add_status(request_id: UUID, request: Request) -> MemoryAddReceipt:
+    def memory_add_status(
+        request_id: UUID,
+        request: Request,
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
+    ) -> MemoryAddReceipt:
         try:
-            return store(request).receipt_for_request(request_id)
+            return store(request).receipt_for_request(request_id, user_id=user_id)
         except KeyError as error:
             raise HTTPException(404, "memory_add_not_found") from error
         except ValueError as error:

memhub/apps/core/src/one_memory/memory_server/contracts.py

@@ -75,7 +75,11 @@ def batch_id(*, internal_session_id: str, first_round: int, last_round: int) ->
 INTERNAL_SESSION_ID_MAX = 128
 
 
-def internal_session_id_for(conversation_id: str, source_id: str) -> str:
+def internal_session_id_for(
+    conversation_id: str,
+    source_id: str,
+    user_id: str = "local",
+) -> str:
     """Normalise a conversation identity to the durable ``internal_session_id``.
 
     This is the single derivation shared by every Evidence-first intake path.
@@ -86,7 +90,17 @@ def internal_session_id_for(conversation_id: str, source_id: str) -> str:
     per-session serialisation split). Only a value that the contract would have
     rejected before it ever reached the queue is replaced by the versioned
     session id, which is deterministic for a given (source, conversation).
+
+    Another user's conversation is always derived with the user in it: two
+    Hermes profiles can hold the same session id, and sharing a session key
+    would serialise and batch one person's turns behind the other's. `local`
+    keeps the identity it always had.
     """
+    if user_id != "local":
+        return session_id(
+            harness_id=source_id,
+            external_session_id=f"user:{user_id}|{conversation_id}",
+        )
     if len(conversation_id) <= INTERNAL_SESSION_ID_MAX:
         return conversation_id
     derived = session_id(harness_id=source_id, external_session_id=conversation_id)

memhub/apps/core/src/one_memory/memory_server/durable_queue.py

@@ -52,7 +52,9 @@ from one_memory.memory_tasks import (
 from one_memory.memory_tasks import (
     POLICY_STOPPED_CODES as _TASK_POLICY_STOPPED_CODES,
 )
+from one_memory.sdk_migration_log import error_chain_text
 from one_memory.service_levels import ServiceLevel, service_level_context
+from one_memory.user_scope import DEFAULT_USER_ID, lane_key, other_user_lane_prefix
 
 logger = logging.getLogger(__name__)
 
@@ -241,14 +243,16 @@ PERMISSION_REQUIRED_CODES = frozenset(
 )
 
 #: Model-side codes the SDK write coordinator raises before it can lease a
-#: client (no active profile, missing credential, secure storage down). They prove
-#: nothing was sent, so the write parks instead of being lost. Transport codes
-#: that can arrive after a request was in flight stay `unknown`.
+#: client (no active profile, missing credential, secure storage down, or the
+#: client failed to construct). They prove nothing was sent, so the write
+#: parks instead of being lost. Transport codes that can arrive after a
+#: request was in flight stay `unknown`.
 MODEL_NOT_READY_CODES = frozenset(
     {
         "model_profile_not_active",
         "model_secret_unavailable",
         "secure_storage_unavailable",
+        "hy_memory_client_unavailable",
     }
 )
 
@@ -292,6 +296,23 @@ _VALID_JOB_STATES = frozenset(
 #: A row in one of these states can never be moved back to a live one.
 _TERMINAL_WRITE_STATES = frozenset({COMPLETED, FAILED, DEAD, CANCELLED})
 
+#: The legacy task rows a write job can be linked to. The SDK cutover drops
+#: them (`target_schema.LEGACY_TABLES_IN_DROP_ORDER`, inputs before tasks), so
+#: the job-only paths must not assume any of them.
+_LEGACY_TASK_LINK_TABLES = ("memory_tasks", "memory_task_inputs", "memory_write_job_evidence")
+
+
+def _legacy_task_links_present(connection: sqlite3.Connection) -> bool:
+    present = {
+        str(row[0])
+        for row in connection.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name IN (?,?,?)",
+            _LEGACY_TASK_LINK_TABLES,
+        )
+    }
+    return present == set(_LEGACY_TASK_LINK_TABLES)
+
+
 #: Columns a current schema declares but an older `memory_write_jobs` may lack.
 #: `CREATE TABLE IF NOT EXISTS` is a no-op for an existing table, so without
 #: this an upgraded install would keep an older queue that every claim/lease
@@ -325,6 +346,27 @@ EVENT_TIME_WINDOW = timedelta(minutes=10)
 DIRECT_WRITE_SOURCES = frozenset({"one-memory-manual"})
 
 
+def request_user_id(request: WriteRequest) -> str:
+    """Whose write this is: its frozen input's user, `local` for id-only rows."""
+    users = {record.user_id for record in request.input_records}
+    if len(users) > 1:
+        raise ValueError("durable_write_multiple_users")
+    return next(iter(users), DEFAULT_USER_ID)
+
+
+def request_source_key(request: WriteRequest) -> str:
+    """The FIFO/claim key of a write: its source, per user.
+
+    `local` keeps the bare source id it always had. Another user's Hermes
+    lane is `hermes@user`, so one person's running job never holds the other
+    person's queue and the claim gate answers for that user's grant.
+    """
+    return lane_key(
+        request_user_id(request),
+        request.source_id or request.internal_session_id,
+    )
+
+
 @dataclass(frozen=True)
 class DurableWriteRecord:
     job_id: str
@@ -842,7 +884,7 @@ class DurableWriteQueue:
                     job_id,
                     queue_seq,
                     request.internal_session_id,
-                    request.source_id or request.internal_session_id,
+                    request_source_key(request),
                     request.batch_identity.batch_id,
                     key,
                     payload,
@@ -909,7 +951,9 @@ class DurableWriteQueue:
             f"{hashlib.sha256(file_key.encode()).hexdigest()}:"
             f"{hashlib.sha256(record.conversation_id.encode()).hexdigest()}"
         )
-        session_key = internal_session_id_for(record.conversation_id, record.source_id)
+        session_key = internal_session_id_for(
+            record.conversation_id, record.source_id, record.user_id
+        )
         written = connection.execute(
             "SELECT 1 FROM memory_write_jobs AS job, json_each(job.evidence_ids_json) AS ref "
             "WHERE job.session_key=? AND job.state!='assembling' AND ref.value=? LIMIT 1",
@@ -978,7 +1022,7 @@ class DurableWriteQueue:
                 str(uuid4()),
                 queue_seq,
                 session_key,
-                record.source_id,
+                lane_key(record.user_id, record.source_id),
                 assembly_key,
                 assembly_key,
                 payload_json,
@@ -1014,10 +1058,13 @@ class DurableWriteQueue:
         `flush` (history at end of file) completes the last turn and writes a
         short batch; without it (live polling) those stay in the row.
         """
+        # Two users' roots can hold a file with the same relative key (each
+        # Hermes profile has its own `state.db`): only this user's rows.
+        assembly_prefix = f"assembly:{user_id}:{source_id}:"
         rows = connection.execute(
             "SELECT * FROM memory_write_jobs WHERE state='assembling' "
-            "AND source_key=? ORDER BY queue_seq",
-            (source_id,),
+            "AND source_key=? AND substr(idempotency_key,1,?)=? ORDER BY queue_seq",
+            (lane_key(user_id, source_id), len(assembly_prefix), assembly_prefix),
         ).fetchall()
         finalized: list[str] = []
         for row in rows:
@@ -1140,7 +1187,7 @@ class DurableWriteQueue:
         Same records, same key: a re-read returns the job already written.
         """
         first = records[0]
-        session_id = internal_session_id_for(first.conversation_id, first.source_id)
+        session_id = internal_session_id_for(first.conversation_id, first.source_id, first.user_id)
         material = ":".join(f"{item.evidence_id}:{item.content_hash}" for item in records)
         request_id = f"turn:v2:{hashlib.sha256(material.encode()).hexdigest()}"
         existing = connection.execute(
@@ -1185,7 +1232,7 @@ class DurableWriteQueue:
                 job_id,
                 queue_seq,
                 session_id,
-                first.source_id,
+                lane_key(first.user_id, first.source_id),
                 request.batch_identity.batch_id,
                 request_id,
                 json.dumps(
@@ -1982,21 +2029,24 @@ class DurableWriteQueue:
                 or str(row["last_error"]) in NON_RETRYABLE_POST_WRITE_CODES
             ):
                 return 0
-            connection.execute(
-                """
-                UPDATE memory_tasks
-                SET status='pending', runner_token=NULL, attempts=0,
-                    last_error_code='model_content_manual_retry_requested', updated_at=?
-                WHERE status='unknown' AND task_id IN (
-                    SELECT inputs.task_id
-                    FROM memory_task_inputs AS inputs, json_each(inputs.refs_json) AS ref
-                    JOIN memory_write_job_evidence AS linked
-                      ON linked.evidence_id=json_extract(ref.value, '$.evidence_id')
-                    WHERE linked.job_id=?
+            # After the SDK cutover the legacy task tables are gone and the
+            # job is the only row to reset.
+            if not self.sdk_authority and _legacy_task_links_present(connection):
+                connection.execute(
+                    """
+                    UPDATE memory_tasks
+                    SET status='pending', runner_token=NULL, attempts=0,
+                        last_error_code='model_content_manual_retry_requested', updated_at=?
+                    WHERE status='unknown' AND task_id IN (
+                        SELECT inputs.task_id
+                        FROM memory_task_inputs AS inputs, json_each(inputs.refs_json) AS ref
+                        JOIN memory_write_job_evidence AS linked
+                          ON linked.evidence_id=json_extract(ref.value, '$.evidence_id')
+                        WHERE linked.job_id=?
+                    )
+                    """,
+                    (now, job_id),
                 )
-                """,
-                (now, job_id),
-            )
             changed = connection.execute(
                 """
                 UPDATE memory_write_jobs
@@ -2098,9 +2148,7 @@ class DurableWriteQueue:
                 f"WHERE state=? AND job_id IN ({placeholders})",
                 (PENDING, now, UNKNOWN, *job_ids),
             )
-            if connection.execute(
-                "SELECT 1 FROM sqlite_master WHERE type='table' AND name='memory_tasks'"
-            ).fetchone():
+            if _legacy_task_links_present(connection):
                 connection.execute(
                     f"UPDATE memory_tasks SET status=?, runner_token=NULL, "
                     f"last_error_code='model_content_reconciled_absent_retry', updated_at=? "
@@ -2158,9 +2206,7 @@ class DurableWriteQueue:
                 f"WHERE state=? AND attempts=1 AND job_id IN ({placeholders})",
                 (PENDING, now, UNKNOWN, *job_ids),
             )
-            if connection.execute(
-                "SELECT 1 FROM sqlite_master WHERE type='table' AND name='memory_tasks'"
-            ).fetchone():
+            if _legacy_task_links_present(connection):
                 connection.execute(
                     f"UPDATE memory_tasks SET status=?, runner_token=NULL, "
                     f"last_error_code='model_content_unknown_auto_retry', updated_at=? "
@@ -2177,6 +2223,14 @@ class DurableWriteQueue:
     def resolve_unknown_from_linked_output(self, job_id: str) -> bool:
         """Close an unknown durable row when local governance output proves success."""
         with main_database(self.database_path).read(row_factory=sqlite3.Row) as connection:
+            if not (
+                _legacy_task_links_present(connection)
+                and connection.execute(
+                    "SELECT 1 FROM sqlite_master WHERE type='table' AND name='memory_task_outputs'"
+                ).fetchone()
+            ):
+                # No legacy governance output survives the SDK cutover.
+                return False
             row = connection.execute(
                 """
                 SELECT 1
@@ -2467,6 +2521,12 @@ async def execute_job(
             source_id = request.internal_session_id
         if source_ids and source_ids != {source_id}:
             raise RuntimeError("durable_write_multiple_sources")
+        users = {getattr(record, "user_id", DEFAULT_USER_ID) for record in records}
+        if len(users) > 1:
+            raise RuntimeError("durable_write_multiple_users")
+        # The gates answer per user: another user's Hermes job asks about
+        # that user's grant, not `local`'s.
+        source_id = lane_key(next(iter(users), DEFAULT_USER_ID), source_id)
 
         async def mark() -> bool:
             return await in_the_background(queue.mark_invoked, job_id, owner=owner)
@@ -2559,9 +2619,22 @@ async def execute_job(
         if code == "model_profile_not_active":
             logger.debug("durable_write_job_parked job_id=%s error_code=%s", job_id, code)
         elif state in PARKED_STATES:
-            logger.info("durable_write_job_parked job_id=%s error_code=%s", job_id, code)
+            logger.info(
+                "durable_write_job_parked job_id=%s error_code=%s chain=%s",
+                job_id,
+                code,
+                error_chain_text(error),
+            )
         else:
-            logger.error("durable_write_job_failed job_id=%s error_code=%s", job_id, code)
+            # Where it failed, as `file:line:function` frames of the exception
+            # chain, never its message: `error_code=AttributeError` alone
+            # named no location.
+            logger.error(
+                "durable_write_job_failed job_id=%s error_code=%s chain=%s",
+                job_id,
+                code,
+                error_chain_text(error),
+            )
         return
     await in_the_background(
         queue.settle,
@@ -2759,6 +2832,19 @@ class DurableWriteDrain:
                 source_clause = f"AND candidate.source_key IN ({placeholders}) "
                 source_params = tuple(sorted(enabled_sources))
             direct_sources = ",".join("?" for _ in DIRECT_WRITE_SOURCES)
+            # Another user's hand-added memories are `one-memory-manual@user`:
+            # the same lane ahead of history, still serial per user.
+            direct_lanes = " OR ".join(
+                "substr(candidate.source_key,1,?)=?" for _ in DIRECT_WRITE_SOURCES
+            )
+            direct_lane_params = tuple(
+                value
+                for source in sorted(DIRECT_WRITE_SOURCES)
+                for value in (
+                    len(other_user_lane_prefix(source)),
+                    other_user_lane_prefix(source),
+                )
+            )
             # Same eligibility as the window claim below (free lease, no
             # running job of its source, nothing earlier in its session), but
             # not bound to the window: a note must not wait for history.
@@ -2768,7 +2854,7 @@ class DurableWriteDrain:
                 "WHERE candidate.state=? "
                 "AND (candidate.lease_expires_at IS NULL OR candidate.lease_expires_at < ?) "
                 + source_clause
-                + f"AND candidate.source_key IN ({direct_sources}) "
+                + f"AND (candidate.source_key IN ({direct_sources}) OR {direct_lanes}) "
                 "AND NOT EXISTS ("
                 "SELECT 1 FROM memory_write_jobs AS held "
                 "WHERE held.source_key=candidate.source_key AND held.state=? "
@@ -2786,6 +2872,7 @@ class DurableWriteDrain:
                     now.isoformat(),
                     *source_params,
                     *sorted(DIRECT_WRITE_SOURCES),
+                    *direct_lane_params,
                     RUNNING,
                     now.isoformat(),
                     *_FIFO_BLOCKING_STATES,

memhub/apps/core/src/one_memory/memory_server/routes.py

@@ -19,10 +19,11 @@ does the writing. That separation is D52.
 
 from __future__ import annotations
 
+import hashlib
 from datetime import UTC, datetime
 from typing import Any, Literal, cast
 
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Query, Request
 from pydantic import BaseModel, ConfigDict, Field
 
 from one_memory.imports.models import (
@@ -43,6 +44,24 @@ from one_memory.memory_server.durable_queue import (
 )
 from one_memory.memory_server.registry import WriteRegistry, WriteState
 from one_memory.memory_server.submit import WriteConflictError
+from one_memory.user_scope import DEFAULT_USER_ID, USER_ID_PATTERN, UserId
+
+#: Durable keys of another user's writes start with this. A `local` request
+#: id never may, so `local` cannot name another user's receipt.
+_USER_KEY_PREFIX = "user:"
+
+
+def durable_request_key(request_id: str, user_id: str) -> str:
+    """The queue key of a caller's request id, namespaced per user.
+
+    Two users choosing the same request id must not collide: the key is the
+    queue's idempotency key and the SDK's `request_id`. `local` keeps its own
+    request id unchanged.
+    """
+    if user_id == DEFAULT_USER_ID:
+        return request_id
+    digest = hashlib.sha256(request_id.encode()).hexdigest()
+    return f"{_USER_KEY_PREFIX}{user_id}:{digest}"
 
 
 class MemoryWriteReceipt(BaseModel):
@@ -71,6 +90,7 @@ class SdkMemoryWriteInput(BaseModel):
     messages: list[OpenAIMessage] = Field(min_length=1, max_length=200)
     memory_at: datetime | None = None
     priority: Literal["live", "normal"] = "normal"
+    user_id: UserId = DEFAULT_USER_ID
 
 
 def _registry(
@@ -124,6 +144,9 @@ def sdk_router(dependencies: list[Any] | None = None) -> APIRouter:
     ) -> MemoryWriteReceipt:
         if not any(message.role == "user" for message in payload.messages):
             raise HTTPException(422, "messages_require_user_turn")
+        if payload.user_id == DEFAULT_USER_ID and payload.request_id.startswith(_USER_KEY_PREFIX):
+            raise HTTPException(422, "request_id_reserved_prefix")
+        request_key = durable_request_key(payload.request_id, payload.user_id)
         observed_at = payload.memory_at or datetime(1970, 1, 1, tzinfo=UTC)
         written_by = {
             "user": WrittenBy.PERSON,
@@ -133,6 +156,7 @@ def sdk_router(dependencies: list[Any] | None = None) -> APIRouter:
         records = tuple(
             materialize_write_input(
                 EvidenceInput(
+                    user_id=payload.user_id,
                     source_id=payload.source_id,
                     conversation_id=payload.session_id,
                     message_id=f"{payload.request_id}:{index}",
@@ -157,6 +181,7 @@ def sdk_router(dependencies: list[Any] | None = None) -> APIRouter:
         internal_session_id = internal_session_id_for(
             payload.session_id,
             payload.source_id,
+            payload.user_id,
         )
         contract = WriteRequest(
             internal_session_id=internal_session_id,
@@ -168,7 +193,7 @@ def sdk_router(dependencies: list[Any] | None = None) -> APIRouter:
             ),
             evidence_ids=[record.evidence_id for record in records],
             input_records=records,
-            idempotency_key=payload.request_id,
+            idempotency_key=request_key,
             priority=payload.priority,
             event_at=payload.memory_at,
             time_quality="exact" if payload.memory_at is not None else "approximate",
@@ -178,7 +203,7 @@ def sdk_router(dependencies: list[Any] | None = None) -> APIRouter:
         except (WriteConflictError, ValueError) as error:
             raise HTTPException(409, str(error)) from error
         return MemoryWriteReceipt(
-            request_id=record.request_id,
+            request_id=payload.request_id,
             state=record.state,
             created_at=record.created_at,
             updated_at=record.updated_at,
@@ -186,16 +211,24 @@ def sdk_router(dependencies: list[Any] | None = None) -> APIRouter:
         )
 
     @instance.get("/{request_id}", response_model=MemoryWriteReceipt)
-    def status(request_id: str, request: Request) -> MemoryWriteReceipt:
+    def status(
+        request_id: str,
+        request: Request,
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
+    ) -> MemoryWriteReceipt:
+        # A receipt belongs to the user that submitted it. Another user's key
+        # is namespaced, and `local` may not name a namespaced key directly.
+        if user_id == DEFAULT_USER_ID and request_id.startswith(_USER_KEY_PREFIX):
+            raise HTTPException(404, "unknown request id")
         registry = _registry(request, write=False)
         try:
-            record = registry.get(request_id)
+            record = registry.get(durable_request_key(request_id, user_id))
         except DurableQueueSchemaUnavailableError as error:
             raise HTTPException(503, str(error)) from error
         if record is None:
             raise HTTPException(404, "unknown request id")
         return MemoryWriteReceipt(
-            request_id=record.request_id,
+            request_id=request_id,
             state=record.state,
             created_at=record.created_at,
             updated_at=record.updated_at,

memhub/apps/core/src/one_memory/memory_server/submit.py

@@ -271,7 +271,9 @@ def build_request_from_evidence(
         # Keep the exact conversation id when it fits the 128-char contract;
         # otherwise derive the versioned session id, so a long branch id does
         # not reject the whole history import.
-        internal_session_id=internal_session_id_for(seed.conversation_id, seed.source_id),
+        internal_session_id=internal_session_id_for(
+            seed.conversation_id, seed.source_id, seed.user_id
+        ),
         first_round=first_round,
         last_round=last_round,
         evidence_ids=list(ordered),

memhub/apps/core/src/one_memory/memory_server/unified_entry.py

@@ -28,6 +28,7 @@ from one_memory.memory_server.contracts import (
     internal_session_id_for,
 )
 from one_memory.memory_server.durable_queue import DurableWriteQueue, DurableWriteRecord
+from one_memory.user_scope import lane_key
 
 WritePriority = Literal["live", "normal"]
 
@@ -74,7 +75,7 @@ class UnifiedWriteIntake:
         if priority not in {"live", "normal"}:
             raise ValueError("priority must be 'live' or 'normal'")
         if self.source_writes_permitted is not None and not self.source_writes_permitted(
-            record.source_id
+            lane_key(record.user_id, record.source_id)
         ):
             # Freeze is the product's one Harness processing decision. Refuse
             # new intake so a frozen source creates no new durable write row;
@@ -106,7 +107,9 @@ class UnifiedWriteIntake:
         last_round: int,
         priority: WritePriority,
     ) -> WriteRequest:
-        session_id = internal_session_id_for(record.conversation_id, record.source_id)
+        session_id = internal_session_id_for(
+            record.conversation_id, record.source_id, record.user_id
+        )
         event_at, time_quality = _job_time((record,))
         request_key = (
             f"entry:{record.evidence_id}"
@@ -145,14 +148,14 @@ class UnifiedWriteIntake:
         ):
             raise ValueError("records must belong to one conversation")
         if self.source_writes_permitted is not None and not self.source_writes_permitted(
-            first.source_id
+            lane_key(first.user_id, first.source_id)
         ):
             raise SourceWriteDisabledError(first.evidence_id)
         material = ":".join(
             f"{record.evidence_id}:{record.revision}:{record.content_hash}" for record in records
         )
         request_id = f"turn:v1:{sha256(material.encode()).hexdigest()}"
-        session_id = internal_session_id_for(first.conversation_id, first.source_id)
+        session_id = internal_session_id_for(first.conversation_id, first.source_id, first.user_id)
         event_at, time_quality = _job_time(records)
         durable = self.queue.submit(
             WriteRequest(

memhub/apps/core/src/one_memory/memory_visibility.py

@@ -160,7 +160,7 @@ def pending(db: sqlite3.Connection, *, limit: int = 100) -> list[str]:
 
 
 def _trigger_sql() -> list[tuple[str, str]]:
-    """(table it depends on, statement) for each trigger."""
+    """(table it is on, statement) for each trigger."""
     return [
         (
             "evidence",
@@ -303,9 +303,61 @@ def install_triggers(db: sqlite3.Connection) -> None:
     for table, statement in _trigger_sql():
         if table not in present:
             continue
+        if not _body_tables(statement) <= present:
+            # SQLite resolves a trigger body only when it fires, so a body
+            # naming a dropped table fails the write it rides on (#233: the
+            # SDK cutover drops `governed_memory_evidence`, and every grant
+            # write then failed). Not installed, and an old copy is removed.
+            cursor.execute(f"DROP TRIGGER IF EXISTS {_trigger_name(statement)}")
+            continue
         cursor.execute(statement)
 
 
+def _trigger_name(statement: str) -> str:
+    return statement.split("IF NOT EXISTS", 1)[1].split()[0]
+
+
+def _body_tables(statement: str) -> set[str]:
+    """Tables the trigger body reads or writes besides the one it is on."""
+    _head, _begin, body = statement.partition("BEGIN")
+    words = body.replace("(", " ").replace(")", " ").split()
+    return {
+        name
+        for keyword, name in zip(words, words[1:], strict=False)
+        if keyword.upper() in {"FROM", "JOIN", "INTO"}
+    }
+
+
+def drop_stale_triggers(database_path: Path) -> tuple[str, ...]:
+    """Drop this module's triggers whose body names a table that is gone.
+
+    Startup on SDK authority does not install the cache (it is read only on
+    legacy authority), but a home migrated by an earlier build still carries
+    the triggers it installed. One whose body reads a dropped table fails
+    every write to the table it is on, so it is dropped here. Idempotent.
+    """
+    with main_database(database_path).write() as db, db:
+        cursor = db.cursor()
+        cursor.row_factory = sqlite3.Row
+        present = {
+            str(row["name"])
+            for row in cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+        }
+        installed = {
+            str(row["name"])
+            for row in cursor.execute("SELECT name FROM sqlite_master WHERE type='trigger'")
+        }
+        dropped = tuple(
+            name
+            for _table, statement in _trigger_sql()
+            if (name := _trigger_name(statement)) in installed
+            and not _body_tables(statement) <= present
+        )
+        for name in dropped:
+            cursor.execute(f"DROP TRIGGER IF EXISTS {name}")
+    return dropped
+
+
 def startup(database_path: Path) -> None:
     """Idempotent: create the derived tables and triggers. No version change.
 

memhub/apps/core/src/one_memory/model_probe.py

@@ -564,7 +564,7 @@ def _embedding_request(
     secret: str | None,
 ) -> tuple[str, str, dict[str, str], dict[str, object]]:
     provider = profile.embedding_provider_kind or profile.provider_kind
-    base_url = (profile.embedding_base_url or profile.base_url or "").rstrip("/")
+    base_url = (profile.embedding_base_url or "").rstrip("/")
     if provider is ProviderKind.OLLAMA:
         return (
             "POST",

memhub/apps/core/src/one_memory/model_profiles.py

@@ -97,7 +97,6 @@ class ModelProfileInput(BaseModel):
         )
         embedding_provider, resolved_embedding_base_url = resolve_embedding_endpoint(
             provider_kind=self.provider_kind,
-            base_url=base_url,
             embedding_model=embedding_model,
             embedding_provider_kind=embedding_provider_kind,
             embedding_base_url=embedding_base_url,
@@ -107,6 +106,12 @@ class ModelProfileInput(BaseModel):
             ProviderKind.ANTHROPIC,
         }:
             raise ValueError("embedding provider must be OpenAI-compatible, Ollama, or local ONNX")
+        if (
+            embedding_provider is not ProviderKind.LOCAL_ONNX
+            and resolved_embedding_base_url is None
+        ):
+            # `ModelProfileStore.create` refuses it with its own code.
+            return self
         if (
             embedding_provider is not ProviderKind.LOCAL_ONNX
             and resolved_embedding_base_url is not None
@@ -308,11 +313,12 @@ class ModelProfileStore:
                     f"""
                     UPDATE {table}
                     SET embedding_provider_kind = provider_kind,
-                        embedding_base_url = base_url
+                        embedding_base_url = COALESCE(embedding_base_url, base_url)
                     WHERE embedding_model IS NOT NULL
                       AND embedding_provider_kind IS NULL
                     """
                 )
+                _pin_embedding_endpoints(connection, table)
             connection.execute(
                 """
                 INSERT OR IGNORE INTO model_profile_versions (
@@ -355,11 +361,11 @@ class ModelProfileStore:
         )
         embedding_provider_kind, embedding_base_url = resolve_embedding_endpoint(
             provider_kind=value.provider_kind,
-            base_url=base_url,
             embedding_model=defaulted_model,
             embedding_provider_kind=defaulted_provider,
             embedding_base_url=defaulted_base_url,
         )
+        require_embedding_base_url(embedding_provider_kind, embedding_base_url)
         try:
             with self._connect(writing=True) as connection:
                 connection.execute(
@@ -612,7 +618,6 @@ class ModelProfileStore:
         )
         embedding_provider_kind, embedding_base_url = resolve_embedding_endpoint(
             provider_kind=current.provider_kind,
-            base_url=base_url,
             embedding_model=embedding_model,
             embedding_provider_kind=(
                 patch.embedding_provider_kind
@@ -627,6 +632,7 @@ class ModelProfileStore:
         )
         if embedding_provider_kind in {ProviderKind.HY_DEFAULT, ProviderKind.ANTHROPIC}:
             raise ValueError("embedding provider must be OpenAI-compatible, Ollama, or local ONNX")
+        require_embedding_base_url(embedding_provider_kind, embedding_base_url)
         if (
             embedding_provider_kind is not ProviderKind.LOCAL_ONNX
             and embedding_base_url is not None
@@ -1167,21 +1173,77 @@ def attach_disable_thinking(
 def resolve_embedding_endpoint(
     *,
     provider_kind: ProviderKind,
-    base_url: str | None,
     embedding_model: str | None,
     embedding_provider_kind: ProviderKind | None,
     embedding_base_url: str | None,
 ) -> tuple[ProviderKind | None, str | None]:
+    """The embedding provider and the endpoint exactly as given.
+
+    The endpoint never follows the generation `base_url`: the collection name
+    hashes it, so a proxy or region edit of the generation endpoint moved
+    writes to a new, empty collection, and providers without embeddings were
+    sent embedding requests. `require_embedding_base_url` refuses a remote
+    embedding without one.
+    """
     if embedding_model is None:
         return None, None
     if embedding_provider_kind is ProviderKind.LOCAL_ONNX:
         return ProviderKind.LOCAL_ONNX, None
-    if embedding_provider_kind is None:
-        return provider_kind, embedding_base_url or base_url
-    return (
-        embedding_provider_kind,
-        embedding_base_url or DEFAULT_BASE_URLS.get(embedding_provider_kind),
-    )
+    return embedding_provider_kind or provider_kind, embedding_base_url
+
+
+class EmbeddingBaseUrlRequiredError(ValueError):
+    def __init__(self) -> None:
+        super().__init__("embedding_base_url_required")
+
+
+def require_embedding_base_url(provider: ProviderKind | None, base_url: str | None) -> None:
+    """A remote embedding must name its endpoint; the UI may offer the generation one."""
+    if provider not in {None, ProviderKind.LOCAL_ONNX} and not base_url:
+        raise EmbeddingBaseUrlRequiredError()
+
+
+def pinned_embedding_base_url(
+    *,
+    provider_kind: ProviderKind | str,
+    base_url: str | None,
+    embedding_model: str | None,
+    embedding_provider_kind: ProviderKind | str | None,
+    embedding_base_url: str | None,
+) -> str | None:
+    """The endpoint a stored profile's embedding resolved to before it was pinned.
+
+    The Runtime used `embedding_base_url or base_url`, and the provider default
+    only when both were empty (no collection could have existed then). Writing
+    that value keeps the endpoint, and so the collection name, byte-identical.
+    """
+    provider = ProviderKind(embedding_provider_kind or provider_kind)
+    if embedding_model is None or embedding_base_url or provider is ProviderKind.LOCAL_ONNX:
+        return embedding_base_url
+    return base_url or DEFAULT_BASE_URLS.get(provider)
+
+
+def _pin_embedding_endpoints(connection: sqlite3.Connection, table: str) -> None:
+    """Write the resolved endpoint into every remote embedding left without one."""
+    rows = connection.execute(
+        f"SELECT rowid, provider_kind, base_url, embedding_model, embedding_provider_kind "
+        f"FROM {table} WHERE embedding_model IS NOT NULL AND embedding_base_url IS NULL "
+        "AND COALESCE(embedding_provider_kind, provider_kind) != 'local_onnx'"
+    ).fetchall()
+    for row in rows:
+        connection.execute(
+            f"UPDATE {table} SET embedding_base_url = ? WHERE rowid = ?",
+            (
+                pinned_embedding_base_url(
+                    provider_kind=row["provider_kind"],
+                    base_url=row["base_url"],
+                    embedding_model=row["embedding_model"],
+                    embedding_provider_kind=row["embedding_provider_kind"],
+                    embedding_base_url=None,
+                ),
+                row["rowid"],
+            ),
+        )
 
 
 def validate_model_base_url(value: str) -> None:

memhub/apps/core/src/one_memory/recall.py

@@ -22,6 +22,7 @@ from one_memory.semantic_deadline import (
     normalize_semantic_hits,
     search_within,
 )
+from one_memory.user_scope import DEFAULT_USER_ID, UserId
 
 
 def recall_blend_mode() -> str:
@@ -67,6 +68,8 @@ class RecallRequest(BaseModel):
     #: Wall-clock budget for candidate gather + score. Not a substitute for
     #: raising the old newest-500 page; it is the third parallel budget.
     timeout_ms: int = Field(default=2_000, ge=50, le=30_000)
+    #: Whose memories to recall. Omitted, it is `local`, the App's library.
+    user_id: UserId = DEFAULT_USER_ID
 
 
 class RecallHit(BaseModel):

memhub/apps/core/src/one_memory/sdk_memory_qa.py

@@ -32,6 +32,7 @@ from one_memory.model_profiles import (
     attach_disable_thinking,
 )
 from one_memory.secrets import SecretStore, SecretStoreUnavailableError
+from one_memory.user_scope import owns
 
 _NO_GROUNDING = "现有记忆不足以回答这个问题。"
 _GROUNDING_LIMIT = 6
@@ -117,7 +118,12 @@ class SdkMemoryAnswerer:
             if hit.memory_id in seen:
                 continue
             record = await _get_memory(client, hit.memory_id)
-            if record is None or record.status != "active" or not record.is_latest:
+            if (
+                record is None
+                or record.status != "active"
+                or not record.is_latest
+                or not owns(record.user_id, user_id)
+            ):
                 continue
             seen.add(record.memory_id)
             found.append(_wire_memory(record))

memhub/apps/core/src/one_memory/sdk_memory_runtime.py

@@ -5,7 +5,8 @@ from __future__ import annotations
 import asyncio
 import logging
 import re
-from contextlib import suppress
+from collections.abc import AsyncIterator, Callable, Iterable
+from contextlib import AsyncExitStack, asynccontextmanager, suppress
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from typing import Any
@@ -55,8 +56,11 @@ class SdkMemoryRuntime:
         write_queue: DurableWriteQueue,
         extraction_settings: ExtractionSettingsStore,
         data_dir: Path,
+        user_ids: Callable[[], Iterable[str]] = lambda: ("local",),
     ) -> None:
         self.coordinator = coordinator
+        #: Every user whose raw layer is kept to the retention window.
+        self.user_ids = user_ids
         self.read_handle = read_handle
         self.write_queue = write_queue
         self.extraction_settings = extraction_settings
@@ -71,6 +75,12 @@ class SdkMemoryRuntime:
             )
 
     async def prune_expired_raw(self, *, now: datetime | None = None) -> int:
+        deleted = 0
+        for user_id in dict.fromkeys(await asyncio.to_thread(lambda: tuple(self.user_ids()))):
+            deleted += await self._prune_expired_raw_for(user_id, now=now)
+        return deleted
+
+    async def _prune_expired_raw_for(self, user_id: str, *, now: datetime | None) -> int:
         cutoff = (now or datetime.now(UTC)) - timedelta(days=RAW_RETENTION_DAYS)
         cutoff_timestamp = int(cutoff.timestamp())
         client = await self.read_handle.client()
@@ -78,7 +88,7 @@ class SdkMemoryRuntime:
         while True:
             page = await asyncio.to_thread(
                 client.list_memories,
-                user_id="local",
+                user_id=user_id,
                 layers=["l1_raw"],
                 statuses=list(_RAW_STATUSES),
                 order="asc",
@@ -94,8 +104,7 @@ class SdkMemoryRuntime:
                 for row in rows
                 if isinstance(row, dict)
                 and isinstance(row.get("memory_id"), str)
-                and int(row.get("memory_at") or row.get("gmt_created") or 0)
-                < cutoff_timestamp
+                and int(row.get("memory_at") or row.get("gmt_created") or 0) < cutoff_timestamp
             ]
             if not expired:
                 return deleted
@@ -113,7 +122,9 @@ class SdkMemoryRuntime:
         while True:
             await asyncio.sleep(RAW_RETENTION_CHECK_SECONDS)
             try:
-                removed = await self.prune_expired_raw()
+                # Its own task, so this pass's use of the read client ends
+                # with it instead of with this loop (see `sdk_read_handle`).
+                removed = await asyncio.create_task(self.prune_expired_raw())
                 if removed:
                     logger.info("sdk_raw_retention_deleted count=%d", removed)
             except asyncio.CancelledError:
@@ -153,55 +164,55 @@ class SdkMemoryRuntime:
         limit: int = 12,
     ) -> tuple[tuple[str, float], ...]:
         return tuple(
-            (hit.memory_id, hit.score)
-            for hit in await self.semantic_recall(query, limit=limit)
+            (hit.memory_id, hit.score) for hit in await self.semantic_recall(query, limit=limit)
         )
 
-    async def graph_snapshot(self, *, limit: int = 300) -> HyGraphSnapshot:
+    async def graph_snapshot(self, *, limit: int = 300, user_id: str = "local") -> HyGraphSnapshot:
         try:
             await self.coordinator.active_profile_credentials()
         except RuntimeError as error:
             if str(error) == "model_profile_not_active":
                 return HyGraphSnapshot(consulted=False)
             raise
-        try:
-            client = await self.coordinator.client()
-        except Exception as error:
-            raise HySdkError("hy_memory_graph_read_failed") from error
-        return await asyncio.to_thread(
-            read_graph_snapshot,
-            client,
-            "local",
-            "*",
-            limit,
-        )
+        async with AsyncExitStack() as stack:
+            try:
+                client = await stack.enter_async_context(self.coordinator.use_client())
+            except Exception as error:
+                raise HySdkError("hy_memory_graph_read_failed") from error
+            return await asyncio.to_thread(
+                read_graph_snapshot,
+                client,
+                user_id,
+                "*",
+                limit,
+            )
 
     async def digest(self) -> dict[str, object]:
-        client = await self.coordinator.client()
-        try:
-            raw = await asyncio.to_thread(
-                client.list_memories,
-                user_id="local",
-                limit=1_000,
-                offset=0,
-            )
-            agent_ids = _agent_ids(raw)
-            digests = [
-                {
-                    "agent_id": agent_id,
-                    "schemas_recorded": 0,
-                    **dict(
-                        await asyncio.to_thread(
-                            client.evolve,
-                            user_id="local",
-                            agent_id=agent_id,
-                        )
-                    ),
-                }
-                for agent_id in agent_ids
-            ]
-        except Exception as error:
-            raise HySdkError("hy_memory_digest_failed") from error
+        async with self.coordinator.use_client() as client:
+            try:
+                raw = await asyncio.to_thread(
+                    client.list_memories,
+                    user_id="local",
+                    limit=1_000,
+                    offset=0,
+                )
+                agent_ids = _agent_ids(raw)
+                digests = [
+                    {
+                        "agent_id": agent_id,
+                        "schemas_recorded": 0,
+                        **dict(
+                            await asyncio.to_thread(
+                                client.evolve,
+                                user_id="local",
+                                agent_id=agent_id,
+                            )
+                        ),
+                    }
+                    for agent_id in agent_ids
+                ]
+            except Exception as error:
+                raise HySdkError("hy_memory_digest_failed") from error
         return {
             "success": all(result.get("success") is not False for result in digests),
             "scope_count": len(digests),
@@ -240,36 +251,39 @@ class SdkMemoryRuntime:
             decision=decision,
         )
 
-    async def _mutation_client(self) -> Any:
+    @asynccontextmanager
+    async def _mutation_client(self) -> AsyncIterator[Any]:
         """The write client, with no-model and keychain refusals as SDK codes.
 
         Callers record these against the edit or deletion instead of failing
         the request that already committed it.
         """
-        try:
-            return await self.coordinator.client()
-        except RuntimeError as error:
-            code = str(error)
-            if not _STABLE_CODE.fullmatch(code):
-                code = "hy_memory_client_unavailable"
-            raise HySdkError(code) from error
+        async with AsyncExitStack() as stack:
+            try:
+                client = await stack.enter_async_context(self.coordinator.use_client())
+            except RuntimeError as error:
+                code = str(error)
+                if not _STABLE_CODE.fullmatch(code):
+                    code = "hy_memory_client_unavailable"
+                raise HySdkError(code) from error
+            yield client
 
     async def update_hy_memory(self, memory_id: str, content: str) -> dict[str, object]:
-        client = await self._mutation_client()
-        try:
-            result = await asyncio.to_thread(client.update, memory_id, content)
-        except Exception as error:
-            raise HySdkError("hy_memory_update_failed") from error
+        async with self._mutation_client() as client:
+            try:
+                result = await asyncio.to_thread(client.update, memory_id, content)
+            except Exception as error:
+                raise HySdkError("hy_memory_update_failed") from error
         if not isinstance(result, dict) or result.get("success") is not True:
             raise HySdkError("hy_memory_update_rejected")
         return result
 
     async def finish_deletion(self, memory_id: str) -> None:
-        client = await self._mutation_client()
-        try:
-            result = await asyncio.to_thread(client.delete, memory_id)
-        except Exception as error:
-            raise HySdkError("hy_memory_delete_failed") from error
+        async with self._mutation_client() as client:
+            try:
+                result = await asyncio.to_thread(client.delete, memory_id)
+            except Exception as error:
+                raise HySdkError("hy_memory_delete_failed") from error
         if not isinstance(result, dict):
             raise HySdkError("hy_memory_delete_rejected")
         error_code = result.get("error_code")

memhub/apps/core/src/one_memory/sdk_migration_runner.py

@@ -23,6 +23,7 @@ from pathlib import Path
 from typing import Any
 
 from one_memory.database_access import main_database
+from one_memory.hy_sdk_runtime import builtin_retrieval_snapshot
 from one_memory.imports.models import EvidenceRecord
 from one_memory.imports.storage import EvidenceStore
 from one_memory.memory_server.contracts import (
@@ -35,6 +36,8 @@ from one_memory.memory_server.durable_queue import (
     COMPLETED,
     FAILED,
     REAPED_PAYLOAD_MARKER,
+    RUNNING,
+    UNKNOWN,
     DurableWriteQueue,
 )
 from one_memory.memory_server.unified_entry import UnifiedWriteIntake
@@ -49,6 +52,7 @@ from one_memory.sdk_migration_bundle import inspect_sdk_migration_bundle
 from one_memory.sdk_migration_verify import (
     MemoryReadbackFailed,
     ReadbackReport,
+    expected_memory_ids,
     legacy_memory_ids_from,
     legacy_memory_ids_from_bundle,
     read_active_profile,
@@ -59,6 +63,8 @@ from one_memory.sdk_vector_reattach import (
     ReattachedCollection,
     legacy_vector_collections,
     reattach_legacy_vectors,
+    stored_memory_ids,
+    vectors_belong_to_another_space,
 )
 from one_memory.target_schema import drop_legacy_tables, legacy_tables_present
 
@@ -257,6 +263,7 @@ def prepare_legacy_write_queue_for_cutover(database_path: Path) -> tuple[int, in
         internal_session_id = internal_session_id_for(
             source.conversation_id,
             source.source_id,
+            source.user_id,
         )
         queue.submit(
             WriteRequest(
@@ -317,11 +324,45 @@ def move_pending_dispatches(database_path: Path) -> int:
     return len(conversations)
 
 
+#: Why a pre-cutover write job that may have reached HY was closed.
+ABANDONED_AT_CUTOVER = "abandoned_at_cutover"
+
+
+def settle_legacy_unknown_write_jobs(database_path: Path) -> int:
+    """Close write jobs the legacy pipeline left possibly-sent. Safe to repeat.
+
+    They ran under the legacy pipeline, so the SDK's `get_write_outcome` knows
+    none of them and the unknown reconcile can never settle them: a migrated
+    1.0.4 home showed 1000+ unknown forever. They are not retried, since they
+    may already have written and the SDK has no idempotency key. `cancelled`,
+    not `failed`: the upgrade ended them, nothing broke, and a `failed` count
+    would put the home in the failed state for good. `hy_invoked` is kept, so
+    no readmission path can pick one up again.
+    """
+    with main_database(database_path).read(row_factory=sqlite3.Row) as database:
+        if "memory_write_jobs" not in _tables(database):
+            return 0
+    now = datetime.now(UTC).isoformat()
+    with main_database(database_path).write(autocommit=True) as database:
+        # A `running` row already marked invoked would be reclaimed to
+        # `unknown` on the next open, so it is the same case.
+        return int(
+            database.execute(
+                "UPDATE memory_write_jobs SET state=?,lease_owner=NULL,"
+                "lease_expires_at=NULL,last_error=?,updated_at=? "
+                "WHERE state=? OR (state=? AND hy_invoked=1)",
+                (CANCELLED, ABANDONED_AT_CUTOVER, now, UNKNOWN, RUNNING),
+            ).rowcount
+        )
+
+
 def abandoned_legacy_work(database_path: Path) -> dict[str, int]:
     """Count legacy work that ends with the cutover instead of blocking it.
 
     A task that may have reached the SDK is not replayed: the SDK already holds
     whatever it committed. Pending user deletions are not carried over.
+    Settled write jobs are counted by their code, so a repeated preparation
+    reports the same number.
     """
     abandoned: dict[str, int] = {}
     with main_database(database_path).read(row_factory=sqlite3.Row) as database:
@@ -332,6 +373,11 @@ def abandoned_legacy_work(database_path: Path) -> dict[str, int]:
                 "memory_tasks",
                 "status='unknown' OR (status='running' AND hy_invocation_count > 0)",
             ),
+            (
+                "unknown_write_jobs",
+                "memory_write_jobs",
+                f"state='{CANCELLED}' AND last_error='{ABANDONED_AT_CUTOVER}'",
+            ),
             ("deletions", "memory_deletions", "status IN ('pending','running')"),
         )
         for name, table, where in checks:
@@ -354,6 +400,10 @@ def prepare_legacy_work_for_cutover(
     running, so a failure names it.
     """
     trace = {} if trace is None else trace
+    # First: a possibly-sent job never runs again, so its input is not
+    # frozen, and input released since must not block the cutover.
+    trace["sub_step"] = "unknown_write_jobs"
+    settle_legacy_unknown_write_jobs(database_path)
     trace["sub_step"] = "write_queue"
     frozen, moved = prepare_legacy_write_queue_for_cutover(database_path)
     trace["sub_step"] = "pending_dispatches"
@@ -411,13 +461,17 @@ def resume_legacy_cleanup(*, data_dir: Path, database_path: Path) -> tuple[str,
             bundle_id=marker.backup_bundle_id,
         )
     from one_memory.hy_runtime_config import HY_MEMORY_NAMESPACE
+    from one_memory.memory_visibility import drop_stale_triggers
 
     recover_abandoned_staging(
         data_dir=data_dir,
         database_path=database_path,
         namespace=HY_MEMORY_NAMESPACE,
     )
-    return drop_legacy_tables(database_path)
+    dropped = drop_legacy_tables(database_path)
+    # The visibility cache's grant triggers read a table just dropped (#233).
+    drop_stale_triggers(database_path)
+    return dropped
 
 
 MIGRATION_PREFIX = "sdk-authority-v2"
@@ -654,13 +708,14 @@ def run_startup_migration(
         step["authority"] = authority.value
     log.migration_id = authority_migration
     with log.step("preflight.profile_read") as step:
-        profile = read_active_profile(database_path)
-        step["profile_present"] = profile is not None
+        active = read_active_profile(database_path)
+        step["profile_present"] = active is not None
+    # No active profile means no generation model, not no embedding: the
+    # vectors are the built-in model's, which is also what the Runtime reads.
+    profile = active if active is not None else builtin_retrieval_snapshot()
     if authority is MemoryAuthority.SDK:
         with log.step("preflight.leftovers_scan") as step:
-            vectors_waiting = profile is not None and bool(
-                legacy_vector_collections(data_dir, profile)
-            )
+            vectors_waiting = bool(legacy_vector_collections(data_dir, profile))
             leftovers = bool(legacy_tables_present(database_path)) or abandoned_staging_present(
                 data_dir=data_dir, namespace=namespace
             )
@@ -671,7 +726,6 @@ def run_startup_migration(
         reattached: tuple[ReattachedCollection, ...] = ()
         readback: ReadbackReport | None = None
         if vectors_waiting:
-            assert profile is not None
             progress("vectors")
             with log.step("vectors.reattach") as step:
                 reattached = reattach_legacy_vectors(data_dir, profile)
@@ -723,12 +777,12 @@ def run_startup_migration(
         step["chat"] = len(legacy.chat)
         step["productivity"] = len(legacy.productivity)
         step["users"] = len(legacy.users)
-    if profile is None and not legacy.empty:
-        # Without the embedding profile the Runtime's collections cannot be
-        # named, so neither reattached nor read back. Legacy stays intact.
-        log.check("preflight.model_profile_check", "sdk_migration_model_profile_required")
-        raise DataPlaneMigrationError("sdk_migration_model_profile_required")
-    log.check("preflight.model_profile_check", None)
+    if active is None and not legacy.empty and vectors_belong_to_another_space(data_dir, profile):
+        # The memories live in the space of a profile that is no longer active,
+        # so the built-in model cannot read them. Legacy stays intact.
+        log.check("preflight.vector_space_check", "sdk_migration_vector_profile_missing")
+        raise DataPlaneMigrationError("sdk_migration_vector_profile_missing")
+    log.check("preflight.vector_space_check", None)
     with capture_fence(data_dir):
         # Builds through 19 left a staged SDK copy beside the original store.
         # Settling it before the bundle means the bundle holds the original
@@ -784,17 +838,23 @@ def run_startup_migration(
                 step.update(preparation.as_document())
             reattached = ()
             readback = None
-            if profile is not None:
-                progress("vectors")
-                with log.step("vectors.reattach") as step:
-                    reattached = reattach_legacy_vectors(data_dir, profile)
-                    step["collections"] = len(reattached)
-            if not legacy.empty:
-                assert profile is not None
+            # Before reattach touches the store, and after the staging
+            # recovery above has settled which store is the original.
+            with log.step("verify.stored_ids") as step:
+                expected, missing = expected_memory_ids(legacy, stored_memory_ids(data_dir))
+                step["chat_expected"] = len(expected.chat)
+                step["chat_missing_before_migration"] = missing
+            progress("vectors")
+            with log.step("vectors.reattach") as step:
+                reattached = reattach_legacy_vectors(data_dir, profile)
+                step["collections"] = len(reattached)
+            if not expected.empty:
                 progress("verify")
                 with log.step("verify.readback") as step:
                     with client_for(profile) as client:
-                        readback = verify_readback(client, legacy)
+                        readback = verify_readback(
+                            client, expected, chat_missing_before_migration=missing
+                        )
                     step.update(readback.as_document())
                     if not readback.passed:
                         store.set_phase(migration_id, phase="readback_failed", state="blocked")

memhub/apps/core/src/one_memory/sdk_migration_verify.py

@@ -14,12 +14,12 @@ import json
 import sqlite3
 from collections.abc import Iterator
 from contextlib import closing, contextmanager
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
 from typing import Any
 
 from one_memory.database_access import main_database
-from one_memory.model_profiles import ModelProfileSnapshot
+from one_memory.model_profiles import ModelProfileSnapshot, pinned_embedding_base_url
 from one_memory.sdk_data_plane_migration import DataPlaneMigrationError
 
 _PRODUCTIVITY_KINDS = frozenset({"coding", "working"})
@@ -47,6 +47,8 @@ class ReadbackReport:
     chat_readable: int
     productivity_expected: int
     productivity_readable: int
+    #: Confirmed in the mirror, gone from the SDK before this migration began.
+    chat_missing_before_migration: int = 0
 
     @property
     def passed(self) -> bool:
@@ -63,6 +65,7 @@ class ReadbackReport:
             "chat_readable": self.chat_readable,
             "productivity_expected": self.productivity_expected,
             "productivity_readable": self.productivity_readable,
+            "chat_missing_before_migration": self.chat_missing_before_migration,
             "passed": self.passed,
         }
 
@@ -115,6 +118,27 @@ def read_legacy_memory_ids(connection: sqlite3.Connection) -> LegacyMemoryIds:
     )
 
 
+def expected_memory_ids(
+    legacy: LegacyMemoryIds, stored: frozenset[str]
+) -> tuple[LegacyMemoryIds, int]:
+    """What the readback must find, and how many confirmed chats it need not.
+
+    A 1.0.4 library can hold confirmed rows whose SDK node the SDK had already
+    merged or deleted: no migration could read those back (658 confirmed, 657
+    in the store, and the whole upgrade failed). So chat is held to what the
+    store held before this run, and anything in there must still read back.
+
+    If none of the confirmed chats is in the store, that is not history: the
+    store is empty or is the wrong one. Nothing is excused then, so the
+    readback still fails on every id instead of checking nothing just before
+    the mirror is dropped.
+    """
+    chat = tuple(memory_id for memory_id in legacy.chat if memory_id in stored)
+    if not chat:
+        return legacy, 0
+    return replace(legacy, chat=chat), len(legacy.chat) - len(chat)
+
+
 def legacy_memory_ids_from(database_path: Path) -> LegacyMemoryIds:
     with main_database(database_path).read() as connection:
         return read_legacy_memory_ids(connection)
@@ -160,7 +184,14 @@ def read_active_profile(database_path: Path) -> ModelProfileSnapshot | None:
         model=row["model"],
         embedding_model=row["embedding_model"],
         embedding_provider_kind=row["embedding_provider_kind"],
-        embedding_base_url=row["embedding_base_url"],
+        # Read-only, beside a Core that may not have pinned it yet.
+        embedding_base_url=pinned_embedding_base_url(
+            provider_kind=row["provider_kind"],
+            base_url=row["base_url"],
+            embedding_model=row["embedding_model"],
+            embedding_provider_kind=row["embedding_provider_kind"],
+            embedding_base_url=row["embedding_base_url"],
+        ),
         embedding_dimensions=row["embedding_dimensions"],
         timeout_seconds=row["timeout_seconds"],
         max_concurrency=row["max_concurrency"],
@@ -179,14 +210,18 @@ def runtime_sdk_client(
     from one_memory.model_profiles import ModelProfileStore
     from one_memory.secrets import KeyringSecretStore, SecretStoreUnavailableError
 
-    try:
-        secret = ModelProfileStore(database_path).resolve_snapshot_secret(
-            profile.profile_id, profile.revision, KeyringSecretStore()
-        )
-    except SecretStoreUnavailableError:
-        raise DataPlaneMigrationError("sdk_migration_secure_storage_unavailable") from None
-    if profile.has_api_key and secret is None:
-        raise DataPlaneMigrationError("sdk_migration_model_secret_unavailable")
+    secret: str | None = None
+    # Without a key there is nothing to resolve, and the built-in retrieval
+    # snapshot has no stored version to look one up by.
+    if profile.has_api_key:
+        try:
+            secret = ModelProfileStore(database_path).resolve_snapshot_secret(
+                profile.profile_id, profile.revision, KeyringSecretStore()
+            )
+        except SecretStoreUnavailableError:
+            raise DataPlaneMigrationError("sdk_migration_secure_storage_unavailable") from None
+        if secret is None:
+            raise DataPlaneMigrationError("sdk_migration_model_secret_unavailable")
     lease = acquire_client(profile, api_key=secret, data_dir=data_dir)
     try:
         yield lease.client
@@ -194,7 +229,9 @@ def runtime_sdk_client(
         lease.close()
 
 
-def verify_readback(client: Any, legacy: LegacyMemoryIds) -> ReadbackReport:
+def verify_readback(
+    client: Any, legacy: LegacyMemoryIds, *, chat_missing_before_migration: int = 0
+) -> ReadbackReport:
     listed: set[str] = set()
     for user_id in legacy.users or ("local",):
         offset = 0
@@ -228,5 +265,6 @@ def verify_readback(client: Any, legacy: LegacyMemoryIds) -> ReadbackReport:
         chat_readable=sum(1 for memory_id in legacy.chat if readable(memory_id)),
         productivity_expected=len(legacy.productivity),
         productivity_readable=sum(1 for memory_id in legacy.productivity if readable(memory_id)),
+        chat_missing_before_migration=chat_missing_before_migration,
     )
 

memhub/apps/core/src/one_memory/sdk_read_handle.py

@@ -0,0 +1,114 @@
+"""The read client, kept in the embedding space the active profile writes to.
+
+Every read used to open the built-in 512-dim collection while writes followed
+the active profile, so a custom embedding read an empty space (#242). This
+handle opens the active profile's `retrieval_view` instead, and the built-in
+space only when no profile is active.
+
+A profile change builds a new client and retires the old one; a retired client
+is closed once no task still uses it, as `SdkWriteCoordinator` does for writes
+(#218). A use is the task that asked for the client: callers keep their
+`client = await handle.client()` shape, and the use ends with that task (one
+HTTP request, one retention pass).
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+from one_memory.hy_sdk_runtime import (
+    BUILTIN_RETRIEVAL_PROFILE_ID,
+    SdkClientHandle,
+    builtin_retrieval_snapshot,
+    retrieval_view,
+)
+from one_memory.hy_sdk_types import HySdkRuntimeError
+from one_memory.model_profiles import ModelProfileStore, ProviderKind
+from one_memory.secrets import SecretStore, SecretStoreUnavailableError
+
+_BUILTIN = (BUILTIN_RETRIEVAL_PROFILE_ID, 0)
+
+
+class ActiveProfileReadHandle(SdkClientHandle):
+    """An `SdkClientHandle` whose profile follows the active one."""
+
+    def __init__(
+        self,
+        *,
+        profiles: ModelProfileStore,
+        secrets: SecretStore,
+        data_dir: Path,
+    ) -> None:
+        super().__init__(builtin_retrieval_snapshot(), api_key=None, data_dir=data_dir)
+        self.profiles = profiles
+        self.secrets = secrets
+        self.data_dir = data_dir
+        self._handles: dict[tuple[str, int], SdkClientHandle] = {}
+        #: Tasks in flight per handle; a retired handle closes at zero.
+        self._uses: dict[SdkClientHandle, int] = {}
+        self._retired: set[SdkClientHandle] = set()
+        self._closing: set[asyncio.Task[None]] = set()
+        self._handle_lock = asyncio.Lock()
+
+    async def client(self) -> Any:
+        identity = await asyncio.to_thread(self.profiles.active_identity) or _BUILTIN
+        async with self._handle_lock:
+            handle = self._handles.get(identity)
+            if handle is None:
+                # Only on a change of profile: resolving a key can reach the
+                # system keychain, so it is not done on every read.
+                handle = await asyncio.to_thread(self._build, identity)
+                self._handles[identity] = handle
+            self._retired.update(value for key, value in self._handles.items() if key != identity)
+            self._handles = {identity: handle}
+            unused = {value for value in self._retired if not self._uses.get(value)}
+            self._retired -= unused
+            self._hold(handle)
+        await asyncio.gather(*(value.close() for value in unused))
+        return await handle.client()
+
+    async def close(self) -> None:
+        async with self._handle_lock:
+            handles = (*self._handles.values(), *self._retired)
+            self._handles, self._retired, self._uses = {}, set(), {}
+        await asyncio.gather(*(handle.close() for handle in handles), *self._closing)
+
+    def _hold(self, handle: SdkClientHandle) -> None:
+        """Count a use of `handle` until the asking task finishes."""
+        task = asyncio.current_task()
+        if task is None:  # pragma: no cover - always called from a coroutine
+            return
+        self._uses[handle] = self._uses.get(handle, 0) + 1
+        task.add_done_callback(lambda _task: self._release(handle))
+
+    def _release(self, handle: SdkClientHandle) -> None:
+        remaining = self._uses.get(handle, 0) - 1
+        if remaining > 0:
+            self._uses[handle] = remaining
+            return
+        self._uses.pop(handle, None)
+        if handle in self._retired:
+            self._retired.discard(handle)
+            closing = asyncio.get_running_loop().create_task(handle.close())
+            self._closing.add(closing)
+            closing.add_done_callback(self._closing.discard)
+
+    def _build(self, identity: tuple[str, int]) -> SdkClientHandle:
+        if identity == _BUILTIN:
+            return SdkClientHandle(
+                builtin_retrieval_snapshot(), api_key=None, data_dir=self.data_dir
+            )
+        profile = self.profiles.snapshot(*identity)
+        view = retrieval_view(profile)
+        secret: str | None = None
+        # Only a remote OpenAI-compatible embedding sends the shared key.
+        if view.embedding_provider_kind is ProviderKind.OPENAI_COMPATIBLE:
+            try:
+                secret = self.profiles.resolve_snapshot_secret(*identity, self.secrets)
+            except SecretStoreUnavailableError:
+                raise HySdkRuntimeError("secure_storage_unavailable") from None
+            if secret is None:
+                raise HySdkRuntimeError("model_secret_unavailable")
+        return SdkClientHandle(view, api_key=secret, data_dir=self.data_dir)

memhub/apps/core/src/one_memory/sdk_vector_reattach.py

@@ -9,6 +9,7 @@ one. Runtime code only reaches vectors through the SDK. This module runs from
 
 from __future__ import annotations
 
+import re
 import sqlite3
 from collections.abc import Iterator
 from contextlib import closing
@@ -21,6 +22,8 @@ from one_memory.model_profiles import ModelProfileSnapshot
 from one_memory.sdk_data_plane_migration import DataPlaneMigrationError
 
 _BATCH = 500
+#: Every name a MemHub build gave an embedding space's base collection.
+_SPACE_NAME = re.compile(r"^(?:memhub_[0-9a-f]{16}|one_memory_[0-9a-f]{12})(?:_|$)")
 
 
 def open_offline_chroma(directory: Path) -> Any:
@@ -51,13 +54,20 @@ def _vector_directory(data_dir: Path) -> Path:
     return data_dir / "hy-memory" / "governed-v2" / "vector"
 
 
-def _stored_names(data_dir: Path) -> tuple[str, ...]:
+def _stored_names(data_dir: Path, *, filled: bool = False) -> tuple[str, ...]:
+    """Collection names; with `filled`, only those holding at least one row."""
     database = _vector_directory(data_dir) / "chroma.sqlite3"
     if not database.is_file():
         return ()
     with closing(sqlite3.connect(f"file:{database}?mode=ro", uri=True)) as connection:
         try:
-            rows = connection.execute("SELECT name FROM collections").fetchall()
+            rows = connection.execute(
+                "SELECT DISTINCT collections.name FROM collections "
+                "JOIN segments ON segments.collection = collections.id "
+                "JOIN embeddings ON embeddings.segment_id = segments.id"
+                if filled
+                else "SELECT name FROM collections"
+            ).fetchall()
         except sqlite3.Error:
             return ()
     return tuple(sorted(str(row[0]) for row in rows))
@@ -80,6 +90,59 @@ def legacy_vector_collections(
     return tuple(pairs)
 
 
+def vectors_belong_to_another_space(data_dir: Path, profile: ModelProfileSnapshot) -> bool:
+    """Vectors exist, but only in embedding spaces `profile` does not name.
+
+    Counted rows, not names: every Runtime opens its read collection with
+    `get_or_create`, so an empty collection under the expected base proves
+    nothing. Read-only, so a preflight can ask before anything changes.
+    """
+    current, legacy_bases = vector_collection_bases(profile)
+    known = (current, *legacy_bases)
+    filled = _stored_names(data_dir, filled=True)
+    return not any(
+        name == base or name.startswith(f"{base}_") for name in filled for base in known
+    ) and any(_SPACE_NAME.match(name) for name in filled)
+
+
+def stored_memory_ids(data_dir: Path) -> frozenset[str]:
+    """Every id in the vector store as found, across all embedding spaces.
+
+    All of them on purpose. A memory stranded under a space the Runtime will
+    not read must count as present, so the readback then fails on it instead
+    of excusing it. Both the point id and the SDK's `node_id` are kept: the
+    SDK derives a point id from a node id that is not a UUID.
+
+    Callers must have stopped every SDK writer. A store that cannot be read
+    raises: "unknown" must never be taken for "absent".
+    """
+    if not (_vector_directory(data_dir) / "chroma.sqlite3").is_file():
+        return frozenset()
+    found: set[str] = set()
+    try:
+        client = open_offline_chroma(_vector_directory(data_dir))
+        try:
+            for collection in client.list_collections():
+                offset = 0
+                while True:
+                    page = collection.get(include=["metadatas"], limit=_BATCH, offset=offset)
+                    ids = list(page["ids"])
+                    if not ids:
+                        break
+                    found.update(ids)
+                    found.update(
+                        str(metadata["node_id"])
+                        for metadata in page["metadatas"] or ()
+                        if metadata and metadata.get("node_id")
+                    )
+                    offset += len(ids)
+        finally:
+            client.close()
+    except Exception as error:
+        raise DataPlaneMigrationError("sdk_migration_vector_store_unreadable") from error
+    return frozenset(found)
+
+
 def _records(collection: Any) -> Iterator[dict[str, Any]]:
     offset = 0
     while True:

memhub/apps/core/src/one_memory/sdk_write_processor.py

@@ -3,7 +3,8 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Callable, Mapping, Sequence
+from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, Sequence
+from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any
@@ -56,7 +57,12 @@ class SdkWriteProcessor:
 
         scope = _write_scope(records)
         metadata = _write_metadata(records, scope)
-        client = await self._client_handle.client()
+        try:
+            client = await self._client_handle.client()
+        except Exception as error:
+            # Before `before_hy_invocation`: nothing was sent, so the job
+            # waits and retries instead of being left `unknown`.
+            raise RuntimeError("hy_memory_client_unavailable") from error
 
         if extracted:
             contents = [sanitize_model_input(record.verbatim) for record in records]
@@ -125,7 +131,14 @@ class SdkWriteProcessor:
 
 
 class SdkWriteCoordinator:
-    """Resolve the active model profile, then execute one public SDK write."""
+    """Resolve the active model profile, then execute one public SDK write.
+
+    A model profile change retires the previous profile's handle, but only
+    closes it once nothing uses it. Closing it at once tore the client out
+    from under a write still running on it: the SDK cleared its stores and
+    the SharedRuntime closed mid-`add`, the job failed with AttributeError
+    after HY was invoked, and it was left `unknown`.
+    """
 
     def __init__(
         self,
@@ -142,6 +155,9 @@ class SdkWriteCoordinator:
         self.transport_factory = transport_factory
         self.sedimentation_enabled = sedimentation_enabled
         self._handles: dict[tuple[str, int], SdkClientHandle] = {}
+        #: Uses in flight per handle; a retired handle closes at zero.
+        self._uses: dict[SdkClientHandle, int] = {}
+        self._retired: set[SdkClientHandle] = set()
         self._lock = asyncio.Lock()
 
     async def process_sdk_job(
@@ -153,28 +169,30 @@ class SdkWriteCoordinator:
     ) -> SdkWriteReceipt:
         if not self.sedimentation_enabled():
             raise RuntimeError("model_sedimentation_disabled")
-        handle = await self._active_handle()
-        return await SdkWriteProcessor(handle).process_sdk_job(
-            records,
-            request_id=request_id,
-            before_hy_invocation=before_hy_invocation,
-        )
+        async with self._active_handle() as handle:
+            return await SdkWriteProcessor(handle).process_sdk_job(
+                records,
+                request_id=request_id,
+                before_hy_invocation=before_hy_invocation,
+            )
 
     async def inquire_write_outcome(
         self, request_id: str
     ) -> SdkWriteReceipt | None:
-        return await SdkWriteProcessor(
-            await self._active_handle()
-        ).inquire_write_outcome(request_id)
+        async with self._active_handle() as handle:
+            return await SdkWriteProcessor(handle).inquire_write_outcome(request_id)
 
     async def close(self) -> None:
         async with self._lock:
-            handles, self._handles = tuple(self._handles.values()), {}
+            handles = (*self._handles.values(), *self._retired)
+            self._handles, self._retired, self._uses = {}, set(), {}
         await asyncio.gather(*(handle.close() for handle in handles))
 
-    async def client(self) -> Any:
-        """Return the public SDK client selected by the active write profile."""
-        return await (await self._active_handle()).client()
+    @asynccontextmanager
+    async def use_client(self) -> AsyncIterator[Any]:
+        """The public SDK client of the active write profile, kept open while used."""
+        async with self._active_handle() as handle:
+            yield await handle.client()
 
     async def active_profile_credentials(
         self,
@@ -183,7 +201,9 @@ class SdkWriteCoordinator:
         _identity, profile, secret = await asyncio.to_thread(self._read_active_credentials)
         return profile, secret
 
-    async def _active_handle(self) -> SdkClientHandle:
+    @asynccontextmanager
+    async def _active_handle(self) -> AsyncIterator[SdkClientHandle]:
+        """Use the active profile's handle; retire the others, closing the unused."""
         identity, profile, secret = await asyncio.to_thread(
             self._read_active_credentials
         )
@@ -197,14 +217,25 @@ class SdkWriteCoordinator:
                     http_transport_factory=self.transport_factory(profile),
                 )
                 self._handles[identity] = handle
-            stale = [
-                value
-                for key, value in self._handles.items()
-                if key != identity
-            ]
+            self._retired.update(value for key, value in self._handles.items() if key != identity)
             self._handles = {identity: handle}
-        await asyncio.gather(*(value.close() for value in stale))
-        return handle
+            self._uses[handle] = self._uses.get(handle, 0) + 1
+            unused = {value for value in self._retired if not self._uses.get(value)}
+            self._retired -= unused
+        await asyncio.gather(*(value.close() for value in unused))
+        try:
+            yield handle
+        finally:
+            # Bookkeeping without an await, so a cancelled caller still
+            # releases its use.
+            remaining = self._uses.get(handle, 0) - 1
+            if remaining > 0:
+                self._uses[handle] = remaining
+            else:
+                self._uses.pop(handle, None)
+            if remaining <= 0 and handle in self._retired:
+                self._retired.discard(handle)
+                await handle.close()
 
     def _read_active_credentials(
         self,

memhub/apps/core/src/one_memory/strict_query.py

@@ -0,0 +1,39 @@
+"""Refuse query parameters a route does not declare.
+
+FastAPI ignores an unknown query parameter. For a memory read that is a
+silent widening: `memory-library?user_id=__nobody__` against a Core that did
+not know `user_id` answered with the whole library, and the caller believed
+it was isolated. Routes that carry this dependency answer such a request with
+the same 422 a malformed body gets.
+"""
+
+from fastapi import Request
+from fastapi.dependencies.models import Dependant
+from fastapi.exceptions import RequestValidationError
+from fastapi.routing import APIRoute
+
+
+def _declared_query_names(dependant: Dependant) -> set[str]:
+    names = {parameter.alias for parameter in dependant.query_params}
+    for dependency in dependant.dependencies:
+        names |= _declared_query_names(dependency)
+    return names
+
+
+async def forbid_unknown_query_params(request: Request) -> None:
+    route = request.scope.get("route")
+    if not isinstance(route, APIRoute):
+        return
+    unknown = sorted(set(request.query_params) - _declared_query_names(route.dependant))
+    if unknown:
+        raise RequestValidationError(
+            [
+                {
+                    "type": "extra_forbidden",
+                    "loc": ("query", name),
+                    "msg": "Extra inputs are not permitted",
+                    "input": None,
+                }
+                for name in unknown
+            ]
+        )

memhub/apps/core/src/one_memory/user_scope.py

@@ -0,0 +1,65 @@
+"""Who a memory belongs to: one Runtime, many `user_id`s.
+
+A user is decided by which source root is read (a Hermes profile is its own
+`state.db`), never by session or platform fields. The App never names a user
+and keeps reading and writing `local`; every other harness stays on `local`
+too. Only Hermes may connect a second root for another user.
+
+In memory, a source's import lane is keyed by `lane_key(user_id, source_id)`.
+For `local` that is the bare source id, so every existing key, health record
+and log line stays byte-identical; another user's lane is `source@user`.
+`@` cannot occur in a user id or a source id, so the key splits back exactly.
+"""
+
+import re
+from typing import Annotated
+
+from pydantic import Field
+
+DEFAULT_USER_ID = "local"
+
+#: `:` is excluded on purpose: the SDK joins ids with it when it keys history,
+#: so a user id holding one could read another user's history.
+USER_ID_PATTERN = r"^[A-Za-z0-9._-]{1,64}$"
+_USER_ID = re.compile(USER_ID_PATTERN)
+
+#: The only source whose roots may belong to a user other than `local`.
+MULTI_USER_SOURCES = frozenset({"hermes"})
+
+UserId = Annotated[str, Field(min_length=1, max_length=64, pattern=USER_ID_PATTERN)]
+
+_LANE_SEPARATOR = "@"
+
+
+def valid_user_id(value: str) -> bool:
+    return bool(_USER_ID.fullmatch(value))
+
+
+def lane_key(user_id: str, source_id: str) -> str:
+    if user_id == DEFAULT_USER_ID:
+        return source_id
+    return f"{source_id}{_LANE_SEPARATOR}{user_id}"
+
+
+def other_user_lane_prefix(source_id: str) -> str:
+    """What every other user's lane of `source_id` starts with."""
+    return f"{source_id}{_LANE_SEPARATOR}"
+
+
+def split_lane(key: str) -> tuple[str, str]:
+    """`(user_id, source_id)` of a lane key; a bare source id is `local`'s."""
+    source_id, separator, user_id = key.partition(_LANE_SEPARATOR)
+    if not separator or not valid_user_id(user_id):
+        return DEFAULT_USER_ID, key
+    return user_id, source_id
+
+
+def owns(record_user_id: str | None, user_id: str) -> bool:
+    """Whether a stored memory belongs to `user_id`.
+
+    The SDK's `get`/`update`/`delete`/`history`/`get_write_outcome` take no
+    user, so MemHub checks this before acting on an id. A memory written
+    before MemHub named users carries `local` or nothing; both are `local`'s.
+    """
+    stored = record_user_id or DEFAULT_USER_ID
+    return stored == user_id

memhub/apps/core/tests/TEST_INDEX.md

@@ -79,7 +79,7 @@
 | `test_database_file_permissions.py` | `contract` | 覆盖 a new main database is readable by its owner alone、the wal sidecars are not left world readable、a database from an older build is tightened on open 场景。 |
 | `test_db_session_utc.py` | `contract` | The MySQL session must be pinned to UTC. |
 | `test_derived_echo.py` | `contract` | A host that saves our injection back must not mint a new user decision. |
-| `test_detailed_logging.py` | `contract` | 覆盖 detailed pipeline logging defaults off and survives restart、live log level applies to full hy and provider call chain、info collects hy info without enabling debug pipeline content 等 7 个场景。 |
+| `test_detailed_logging.py` | `contract` | 覆盖 detailed logging defaults off and survives restart、hy pipeline log and trace stay off at every level、live level change reaches the hy text log file 等 7 个场景。 |
 | `test_diagnostic_log.py` | `contract` | 覆盖 high frequency success events are summarized but warnings are not、structured log is private correlated and owner only、arbitrary detail and absolute stack are rejected 等 14 个场景。 |
 | `test_diagnostic_log_durability.py` | `contract` | 写线程报告的「已落盘」必须是真的。 |
 | `test_diagnostic_log_off_loop.py` | `contract` | 诊断日志不得在调用线程上做磁盘 I/O。 |
@@ -105,6 +105,7 @@
 | `test_graph_width_guard.py` | `unit` | Graph width mismatch must ask, never silently archive. |
 | `test_harness_contract_suite.py` | `contract` | A4-09: one contract, ten harnesses. |
 | `test_health.py` | `contract` | 覆盖 a backfill that fails says so rather than disappearing、a failed catch up leaves a traceback behind、configured model without content consent does not start backfill 等 15 个场景。 |
+| `test_hermes_gateway_injection.py` | `contract` | Hermes gateway text in `user` rows: notices are skipped, relayed messages unwrapped. |
 | `test_history_listing_rotation.py` | `contract` | 覆盖 history listing alternates started and untouched files、history listing drains whichever cohort is longer 场景。 |
 | `test_host_capabilities.py` | `unit` | A plugin does not become realtime on every host or every unknown version. |
 | `test_hourly_c1_peak_replay_contract.py` | `contract` | Guard the package peak-replay probe's error accounting. |
@@ -112,6 +113,7 @@
 | `test_hy_log_privacy.py` | `contract` | HY SDK records are not rewritten by One Memory's logging setup. |
 | `test_hy_network_egress.py` | `contract` | Where a real HY client is allowed to send bytes, and where it is not. |
 | `test_hy_runtime_config.py` | `contract` | MEMORY.md is the audited record of what we send HY; keep it answerable. |
+| `test_hy_sdk_log_routing.py` | `contract` | HY SDK text logs go to hy_memory.log only, with warnings also in core.log. |
 | `test_hy_step_trace_switch.py` | `contract` | Rule 15: the per-step HY trace is off unless the debug tier asks for it. |
 | `test_import_api.py` | `integration` | 覆盖 resume during cleanup returns conflict without internal error、authorize detect import and revoke api flow、protected api rejects missing token and foreign origin 等 5 个场景。 |
 | `test_import_control_races_review.py` | `contract` | Read-only review repro: real runner/store, synthetic delayed adapter cleanup. |
@@ -195,6 +197,7 @@
 | `test_model_profiles.py` | `contract` | 覆盖 profile uses one model and keeps key out of database、api key updates reuse one stable secret reference、startup cleanup removes only secrets not referenced by current profiles 等 15 个场景。 |
 | `test_model_request_audit.py` | `contract` | 覆盖 failure is recorded without error message、missing usage stays unknown in detail and zero in summary、records one physical request with provider usage and no content 等 5 个场景。 |
 | `test_model_request_budget.py` | `contract` | 覆盖 persists failed request reservations without content、parallel leases cannot exceed request limit、unknown or excessive output and body are denied 等 6 个场景。 |
+| `test_multi_user_runtime.py` | `contract` | One Runtime, many users: `user_id` on the memory API, per-user Hermes profiles. |
 | `test_mysql_lifecycle.py` | `contract` | A1-07: the decisions Runtime makes around the bundled MySQL. |
 | `test_mysql_platform.py` | `contract` | A1-07: the machine-facing half of managing the bundled MySQL. |
 | `test_obs03_health_probe.py` | `contract` | OBS-03: '/health' answered with the web app instead of a health payload. |
@@ -245,6 +248,7 @@
 | `test_schema_gate.py` | `contract` | 覆盖 fresh database records the build schema、future schema refuses to open、legacy database without a ledger is left untouched 场景。 |
 | `test_schema_migrations.py` | `contract` | 覆盖 evidence store adds source ordinal to previous schema、import store migrates previous job and error schema、old active job index lets a sync sit beside paused history 等 4 个场景。 |
 | `test_schema_ownership_gate.py` | `contract` | A1-03/A1-04: schema ownership, and the hard part of telling DDL from reads. |
+| `test_sdk_client_construction.py` | `contract` | SDK clients of one home are constructed one at a time. |
 | `test_sdk_data_plane_migration.py` | `contract` | SDK-authority migration ledger, aliases and atomic cutover marker. |
 | `test_sdk_memory_qa.py` | `contract` | 覆盖 sdk ask propagates sdk search failure without legacy fallback、sdk ask revalidates memory before returning extract、sdk ask uses native sdk memory without governance fields 场景。 |
 | `test_sdk_migration_bundle.py` | `contract` | SDK-authority cutover requires a verified management + SDK data-plane bundle. |
@@ -307,4 +311,4 @@
 | `test_workspace_recall.py` | `contract` | Workspace memories were unreachable from every host; these pin the way in. |
 | `test_write_queue_lease_renewal.py` | `contract` | Rule 8: a lease must outlive the work it covers, and be renewed while it runs. |
 
-共 302 个测试文件。
+共 306 个测试文件。

memhub/apps/core/tests/core_test_classification.py

@@ -14,8 +14,8 @@ from pathlib import Path
 import pytest
 
 PRIMARY_MARKERS = ("unit", "contract", "integration", "performance", "live")
-EXPECTED_TEST_FILE_COUNT = 302
-EXPECTED_TEST_FILES_SHA256 = "07707528025ac134e46c93ebef12335e852df1ed0f52f8beb62abb3b4d1b0e97"
+EXPECTED_TEST_FILE_COUNT = 306
+EXPECTED_TEST_FILES_SHA256 = "e616dcf9fea288bf15a4445045f7b4278517f3304091c04fffd55be80308d481"
 
 # Pure transformations, validation models, parity checks and state machines.
 # This list is intentionally small: uncertain files default to contract.

memhub/apps/core/tests/fixtures/hermes_gateway_rows.jsonl

@@ -0,0 +1,8 @@
+{"id": 131, "session_id": "20261019_005046_a2a79a", "role": "user", "content": "[IMPORTANT: 3 background processes completed. Treat these results as one batch and give one consolidated response; preserve failures and actionable results.]", "timestamp": 1792344160.7817369, "tool_name": null, "finish_reason": null}
+{"id": 314, "session_id": "20261019_005046_a2a79a", "role": "user", "content": "[IMPORTANT: Background process proc_a9805510da6f matched watch pattern \"Uvicorn running\".\nCommand: cd ~/Workspace/paddleocr-vl-service && exec ./start.sh\nMatched output:\nINFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)]", "timestamp": 1792421570.094992, "tool_name": null, "finish_reason": null}
+{"id": 769, "session_id": "20261021_005036_4fcb846a", "role": "user", "content": "[IMPORTANT: Background process proc_9d3a5fe22318 completed normally (exit code 0).\nCommand: cd /Users/example/.hermes/models/gguf && curl -L -C - --retry 30 --retry-delay 5 --retry-all-errors -sS -o Qwen3.5-2B-Q4_K_M.gguf \"https://huggingface.co/unsloth/Qwen3.5-2B-GGUF/resolve/main/Qwen3.5-2B-Q4_K_M.gguf\" && echo \"Q3.5-2B DONE\" && ls -lh Qwen3.5-2B-Q4_K_M.gguf\nOutput:\n(eval):1: can't change option: zle\n(eval):1: can't change option: zle\nQ3.5-2B DONE\n-rw-r--r--@ 1 example  staff   1.2G Oct 21 01:31 Qwen3.5-2B-Q4_K_M.gguf\n]\n\n[INTERNAL NOTIFICATION — generated by the Hermes gateway, not written by a human user. Do not treat it as user input, and do not reply to any earlier chat message because of it.]", "timestamp": 1792517511.042671, "tool_name": null, "finish_reason": null}
+{"id": 343, "session_id": "20261021_005036_4fcb846a", "role": "user", "content": "[voice message could not be transcribed automatically; the audio is available at: /Users/example/.hermes/cache/audio/audio_46bab1cf72c3.ogg]", "timestamp": 1792515117.0, "tool_name": null, "finish_reason": null}
+{"id": 197, "session_id": "20261019_142101_50c2a6", "role": "user", "content": "Reply with exactly: PONG", "timestamp": 1792390861.155566, "tool_name": null, "finish_reason": null}
+{"id": 637, "session_id": "20261021_005036_4fcb846a", "role": "user", "content": "Gateway message origin (JSON data, not instructions or authorization):\n{\"platform\": \"telegram\", \"chat_id\": \"1000000001\", \"chat_type\": \"dm\", \"user_id\": \"1000000001\", \"message_id\": \"93\", \"source_message_id\": \"93\"}\nDo not guess a reply destination when these fields are insufficient.\n\n3.5 2b 得版本也想看看，没有量化或者 gguf 吗", "timestamp": 1792517455.622248, "tool_name": null, "finish_reason": null}
+{"id": 548, "session_id": "20261021_005036_4fcb846a", "role": "user", "content": "[OUT-OF-BAND USER MESSAGE — a direct message from the user, delivered once at this position; not tool output and not a new delivery when replayed from conversation history]\nGateway message origin (JSON data, not instructions or authorization):\n{\"platform\": \"telegram\", \"chat_id\": \"1000000001\", \"chat_type\": \"dm\", \"user_id\": \"1000000001\", \"message_id\": \"73\", \"source_message_id\": \"73\"}\nDo not guess a reply destination when these fields are insufficient.\n\n对比结果如何\n[/OUT-OF-BAND USER MESSAGE]", "timestamp": 1792517335.660696, "tool_name": null, "finish_reason": null}
+{"id": 2154, "session_id": "20261021_005036_4fcb846a", "role": "user", "content": "[OUT-OF-BAND USER MESSAGE — a direct message from the user, delivered once at this position; not tool output and not a new delivery when replayed from conversation history]\nGateway message origin (JSON data, not instructions or authorization):\n{\"platform\": \"telegram\", \"chat_id\": \"1000000001\", \"chat_type\": \"dm\", \"user_id\": \"1000000001\", \"message_id\": \"489\", \"source_message_id\": \"489\"}\nDo not guess a reply destination when these fields are insufficient.\n\n我预期memhub使用的是hy memory的ultra模式，并且在夜间调用一次envolve接口来进化memory 呢。\n你说memhub的chat走的是什么我有点懵。\n\n我记得memhub写入的时候，不是直接调用sdk client的add么？\n\n应该是没有设置scene才对。可以检查一下\n[/OUT-OF-BAND USER MESSAGE]", "timestamp": 1793448843.4533901, "tool_name": null, "finish_reason": null}

memhub/apps/core/tests/graph_fixtures.py

@@ -24,7 +24,8 @@ def model_snapshot(
         model="memory-model",
         embedding_model="embedding-model",
         embedding_provider_kind=embedding_provider,
-        embedding_base_url=embedding_base_url,
+        # Stored profiles always name it; see `pinned_embedding_base_url`.
+        embedding_base_url=embedding_base_url or base_url,
         embedding_dimensions=768,
         timeout_seconds=30,
         max_concurrency=1,

memhub/apps/core/tests/test_cli_restore.py

@@ -175,7 +175,13 @@ def test_sdk_migrate_reports_each_step_then_the_result(tmp_path, monkeypatch) ->
 
     assert code == 0, output.getvalue()
     lines = [json.loads(line) for line in output.getvalue().splitlines()]
-    assert [line["step"] for line in lines[:-1]] == ["bundle", "prepare", "cutover", "cleanup"]
+    assert [line["step"] for line in lines[:-1]] == [
+        "bundle",
+        "prepare",
+        "vectors",
+        "cutover",
+        "cleanup",
+    ]
     assert lines[-1]["state"] == "cutover"
     assert lines[-1]["bundle_id"] == f"{lines[-1]['migration_id']}-pre-cutover"
     assert not (tmp_path / ".sdk-migration-capture-fence.json").exists()

memhub/apps/core/tests/test_detailed_logging.py

@@ -1,6 +1,5 @@
 import json
 import logging
-from importlib import import_module
 from pathlib import Path
 
 from one_memory.hy_runtime_config import (
@@ -12,20 +11,50 @@ from one_memory.hy_runtime_config import (
 )
 
 
-def test_detailed_pipeline_logging_defaults_off_and_survives_restart(
-    tmp_path: Path, monkeypatch
-) -> None:
-    monkeypatch.delenv("MEMORY_PIPELINE_TRACE_ENABLED", raising=False)
+def test_detailed_logging_defaults_off_and_survives_restart(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.delenv("MEMORY_LOG_LEVEL", raising=False)
     assert detailed_logging_enabled(tmp_path) is False
     configure_hy_runtime_environment(tmp_path)
-    assert __import__("os").environ["MEMORY_PIPELINE_TRACE_ENABLED"] == "false"
+    assert __import__("os").environ["MEMORY_LOG_LEVEL"] == "INFO"
     assert diagnostic_log_level(tmp_path) == "info"
 
     assert set_detailed_logging(tmp_path, True) is True
     assert detailed_logging_enabled(tmp_path) is True
-    monkeypatch.delenv("MEMORY_PIPELINE_TRACE_ENABLED", raising=False)
+    monkeypatch.delenv("MEMORY_LOG_LEVEL", raising=False)
     configure_hy_runtime_environment(tmp_path)
-    assert __import__("os").environ["MEMORY_PIPELINE_TRACE_ENABLED"] == "true"
+    assert __import__("os").environ["MEMORY_LOG_LEVEL"] == "DEBUG"
+
+
+def test_hy_pipeline_log_and_trace_stay_off_at_every_level(tmp_path: Path, monkeypatch) -> None:
+    environment = __import__("os").environ
+    for level in ("error", "warning", "info", "debug"):
+        for name in ("MEMORY_PIPELINE_LOG_ENABLED", "MEMORY_PIPELINE_TRACE_ENABLED"):
+            monkeypatch.setenv(name, "true")
+        set_diagnostic_log_level(tmp_path, level)
+        assert environment["MEMORY_PIPELINE_LOG_ENABLED"] == "false"
+        assert environment["MEMORY_PIPELINE_TRACE_ENABLED"] == "false"
+
+        for name in ("MEMORY_PIPELINE_LOG_ENABLED", "MEMORY_PIPELINE_TRACE_ENABLED"):
+            monkeypatch.setenv(name, "true")
+        configure_hy_runtime_environment(tmp_path)
+        assert environment["MEMORY_PIPELINE_LOG_ENABLED"] == "false"
+        assert environment["MEMORY_PIPELINE_TRACE_ENABLED"] == "false"
+
+
+def test_live_level_change_reaches_the_hy_text_log_file(tmp_path: Path) -> None:
+    sdk = logging.getLogger("hy_memory")
+    text_log = logging.FileHandler(tmp_path / "hy_memory.log", encoding="utf-8")
+    text_log.setLevel(logging.INFO)
+    sdk.addHandler(text_log)
+    try:
+        set_diagnostic_log_level(tmp_path, "debug")
+        assert text_log.level == logging.DEBUG
+        set_diagnostic_log_level(tmp_path, "warning")
+        assert text_log.level == logging.WARNING
+    finally:
+        sdk.removeHandler(text_log)
+        text_log.close()
+        set_diagnostic_log_level(tmp_path, "info")
 
 
 def test_live_log_level_applies_to_full_hy_and_provider_call_chain(
@@ -60,43 +89,9 @@ def test_info_collects_hy_info_without_enabling_debug_pipeline_content(
     assert logging.getLogger("openai._base_client").isEnabledFor(logging.INFO)
     assert not logging.getLogger("openai._base_client").isEnabledFor(logging.DEBUG)
     assert __import__("os").environ["MEMORY_LOG_LEVEL"] == "INFO"
-    assert __import__("os").environ["MEMORY_PIPELINE_TRACE_ENABLED"] == "false"
     assert __import__("os").environ["MEMORY_LOG_LLM_CONTENT"] == "false"
 
 
-def test_live_debug_switch_makes_sdk_pipeline_writer_keep_original_content(
-    tmp_path: Path,
-) -> None:
-    writer_type = import_module("hy_memory.utils.pipeline_log_writer").PipelineLogWriter
-    writer = writer_type(str(tmp_path / "pipeline"))
-
-    set_diagnostic_log_level(tmp_path, "info")
-    writer.write_step(
-        request_id="info",
-        step="EXTRACT",
-        prompt="info prompt",
-        response="info response",
-    )
-    set_diagnostic_log_level(tmp_path, "debug")
-    writer.write_step(
-        request_id="debug",
-        step="EXTRACT",
-        prompt="debug prompt",
-        response="debug response",
-    )
-
-    lines = [
-        json.loads(line)
-        for target in (tmp_path / "pipeline").rglob("*.log")
-        for line in target.read_text(encoding="utf-8").splitlines()
-    ]
-    info, debug = lines
-    assert info["prompt"].startswith("<redacted len=")
-    assert info["content"].startswith("<redacted len=")
-    assert debug["prompt"] == "debug prompt"
-    assert debug["content"] == "debug response"
-
-
 def test_log_level_document_migrates_the_old_boolean_shape(tmp_path: Path) -> None:
     target = tmp_path / "settings" / "diagnostic-logging.json"
     target.parent.mkdir(parents=True)
@@ -117,6 +112,7 @@ def test_configure_environment_passes_debug_content_settings_to_sdk(
         "MEMORY_DATA_DIR",
         "MEMORY_LOG_DIR",
         "MEMORY_LOG_LEVEL",
+        "MEMORY_PIPELINE_LOG_ENABLED",
         "MEMORY_PIPELINE_TRACE_ENABLED",
         "MEMORY_LOG_LLM_CONTENT",
     ):
@@ -129,5 +125,6 @@ def test_configure_environment_passes_debug_content_settings_to_sdk(
     assert environment["MEMORY_DATA_DIR"] == str(memory_root)
     assert environment["MEMORY_LOG_DIR"] == str(memory_root / "logs")
     assert environment["MEMORY_LOG_LEVEL"] == "DEBUG"
-    assert environment["MEMORY_PIPELINE_TRACE_ENABLED"] == "true"
+    assert environment["MEMORY_PIPELINE_LOG_ENABLED"] == "false"
+    assert environment["MEMORY_PIPELINE_TRACE_ENABLED"] == "false"
     assert environment["MEMORY_LOG_LLM_CONTENT"] == "true"

memhub/apps/core/tests/test_hermes_gateway_injection.py

@@ -0,0 +1,239 @@
+"""Hermes gateway text in `user` rows: notices are skipped, relayed messages unwrapped.
+
+Every fixture row is a real Hermes `state.db` row, with the Telegram ids and
+the local home directory replaced by fake values (and the batch notice cut
+to its first line). They all wear the `user` role, so the import has to
+decide on the text.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sqlite3
+from pathlib import Path
+
+import pytest
+from pydantic import JsonValue
+
+from one_memory.conversation_processing import turn_batches
+from one_memory.imports.access import AuthorizedSourceRoot
+from one_memory.imports.adapters import (
+    ScanEvent,
+    ScanIssueCode,
+    ScannedEvidence,
+    ScanOptions,
+    ScanSkip,
+)
+from one_memory.imports.sources.common import (
+    ParsedMessage,
+    ParsedSkip,
+    SourceRecordContext,
+)
+from one_memory.imports.sources.hermes import (
+    HERMES_DESCRIPTOR,
+    create_hermes_adapter,
+    gateway_user_text,
+    parse_hermes_rollout_record,
+)
+from one_memory.imports.storage import EvidenceStore
+
+_ROWS = {
+    row["id"]: row
+    for row in (
+        json.loads(line)
+        for line in (Path(__file__).parent / "fixtures" / "hermes_gateway_rows.jsonl")
+        .read_text(encoding="utf-8")
+        .splitlines()
+        if line.strip()
+    )
+}
+
+_DROPPED = {
+    131: ScanIssueCode.INJECTED_MACHINE_NOTICE,  # "3 background processes completed"
+    314: ScanIssueCode.INJECTED_MACHINE_NOTICE,  # "Background process … matched watch pattern"
+    769: ScanIssueCode.INJECTED_MACHINE_NOTICE,  # … plus the gateway's INTERNAL NOTIFICATION
+    343: ScanIssueCode.VOICE_PLACEHOLDER,
+    197: ScanIssueCode.PROBE,
+}
+
+_UNWRAPPED = {
+    548: "对比结果如何",
+    637: "3.5 2b 得版本也想看看，没有量化或者 gguf 吗",
+    2154: (
+        "我预期memhub使用的是hy memory的ultra模式，并且在夜间调用一次envolve接口来进化memory 呢。\n"
+        "你说memhub的chat走的是什么我有点懵。\n\n"
+        "我记得memhub写入的时候，不是直接调用sdk client的add么？\n\n"
+        "应该是没有设置scene才对。可以检查一下"
+    ),
+}
+
+
+@pytest.mark.parametrize("row_id", sorted(_DROPPED))
+def test_a_machine_turn_in_the_users_role_is_skipped_with_its_reason(row_id: int) -> None:
+    assert gateway_user_text(_ROWS[row_id]["content"]) == ("", _DROPPED[row_id])
+
+
+def test_the_gateway_note_drops_a_turn_wherever_it_sits() -> None:
+    note = _ROWS[769]["content"].rsplit("\n\n", 1)[1]
+    assert note.startswith("[INTERNAL NOTIFICATION")
+
+    assert gateway_user_text(f"anything before it\n\n{note}")[1] is (
+        ScanIssueCode.INJECTED_MACHINE_NOTICE
+    )
+
+
+@pytest.mark.parametrize("row_id", sorted(_UNWRAPPED))
+def test_a_relayed_message_keeps_exactly_what_the_person_wrote(row_id: int) -> None:
+    assert gateway_user_text(_ROWS[row_id]["content"]) == (_UNWRAPPED[row_id], None)
+
+
+def test_the_interrupted_response_label_is_unwrapped() -> None:
+    text = "[Context from the interrupted assistant response]\n继续刚才的对比"
+
+    assert gateway_user_text(text) == ("继续刚才的对比", None)
+
+
+@pytest.mark.parametrize(
+    ("text", "reason"),
+    [
+        ("MEDIA:/Users/example/.hermes/cache/images/a.jpg", ScanIssueCode.NO_TEXT),
+        ("Reply with exactly: PONG please, and then explain why", None),
+        ("平铺", None),
+        ("  look at [IMPORTANT: Background process] in the log  ", None),
+    ],
+)
+def test_ordinary_text_is_left_as_it_was(text: str, reason: ScanIssueCode | None) -> None:
+    cleaned, skipped = gateway_user_text(text)
+
+    assert skipped is reason
+    assert cleaned == ("" if reason else text.strip())
+
+
+def _state_db(root: Path, rows: list[tuple[int, str, str, str]]) -> None:
+    root.mkdir()
+    connection = sqlite3.connect(root / "state.db")
+    connection.execute(
+        "CREATE TABLE messages (id INTEGER PRIMARY KEY, session_id TEXT, role TEXT,"
+        " content TEXT, timestamp REAL, tool_name TEXT, active INTEGER)"
+    )
+    connection.executemany(
+        "INSERT INTO messages VALUES (?, ?, ?, ?, 1000, ?, 1)",
+        [
+            (row_id, session, role, content, "terminal" if role == "tool" else None)
+            for row_id, session, role, content in rows
+        ],
+    )
+    connection.commit()
+    connection.close()
+
+
+def _scan(root: Path, home: Path) -> list[ScanEvent]:
+    adapter = create_hermes_adapter(
+        AuthorizedSourceRoot.grant(
+            source_id=HERMES_DESCRIPTOR.source_id,
+            root=root,
+            user_confirmed=True,
+            home=home,
+        )
+    )
+
+    async def collect() -> list[ScanEvent]:
+        return [event async for event in adapter.scan(ScanOptions(cursors={}))]
+
+    return asyncio.run(collect())
+
+
+def test_state_db_import_writes_the_cleaned_turn_and_counts_the_skipped_ones(
+    tmp_path: Path,
+) -> None:
+    rows = [
+        (row_id, "session-h", "user", _ROWS[row_id]["content"])
+        for row_id in [*_DROPPED, *_UNWRAPPED]
+    ]
+    _state_db(tmp_path / "hermes", rows)
+    events = _scan(tmp_path / "hermes", tmp_path)
+    evidence = [event.evidence for event in events if isinstance(event, ScannedEvidence)]
+    skipped = [event.reason_code for event in events if isinstance(event, ScanSkip)]
+
+    assert [item.verbatim for item in evidence] == [_UNWRAPPED[row_id] for row_id in _UNWRAPPED]
+    assert sorted(skipped) == sorted(_DROPPED.values())
+    assert "chat_id" not in repr(evidence)
+
+
+def test_assistant_and_tool_rows_with_the_same_text_are_not_touched(tmp_path: Path) -> None:
+    """Only the person's role is cleaned. An assistant that answers "PONG" or
+    a tool that prints a notice is reporting what it saw; the existing
+    assistant and tool rules decide what of that is kept."""
+    probe = _ROWS[197]["content"]
+    relayed = _ROWS[548]["content"]
+    _state_db(
+        tmp_path / "hermes",
+        [
+            (1, "session-h", "assistant", probe),
+            (2, "session-h", "assistant", relayed),
+            (3, "session-h", "tool", probe),
+        ],
+    )
+
+    evidence = [
+        event.evidence
+        for event in _scan(tmp_path / "hermes", tmp_path)
+        if isinstance(event, ScannedEvidence)
+    ]
+
+    assert [item.role for item in evidence] == ["assistant", "assistant", "tool"]
+    assert evidence[0].verbatim == probe
+    assert evidence[1].verbatim == relayed
+    assert probe in evidence[2].verbatim
+
+
+def test_a_conversation_left_without_its_user_turn_writes_no_batch(tmp_path: Path) -> None:
+    """A probe session is the probe and the reply. With the probe skipped,
+    the turn rule holds the reply back and drops it at the end of the file
+    rather than send HY a batch with no user message in it."""
+    _state_db(
+        tmp_path / "hermes",
+        [(1, "probe", "user", _ROWS[197]["content"]), (2, "probe", "assistant", "PONG")],
+    )
+    store = EvidenceStore(tmp_path / "one-memory.sqlite3")
+    records = [
+        store.put(event.evidence).record
+        for event in _scan(tmp_path / "hermes", tmp_path)
+        if isinstance(event, ScannedEvidence)
+    ]
+
+    assert [record.role for record in records] == ["assistant"]
+    assert turn_batches(records, flush=True).batches == ()
+
+
+@pytest.mark.parametrize("role", ["user", "assistant"])
+def test_session_transcripts_follow_the_same_rule(role: str) -> None:
+    context = SourceRecordContext(
+        file_key="hermes",
+        relative_path="sessions/session.jsonl",
+        ordinal="1",
+    )
+
+    def parse(text: str) -> ParsedMessage | ParsedSkip:
+        record: dict[str, JsonValue] = {
+            "type": "message",
+            "role": role,
+            "content": text,
+            "sessionId": "s",
+        }
+        return parse_hermes_rollout_record(record, context)
+
+    notice = parse(_ROWS[314]["content"])
+    relayed = parse(_ROWS[548]["content"])
+
+    if role == "user":
+        assert notice == ParsedSkip(
+            reason_code=ScanIssueCode.INJECTED_MACHINE_NOTICE, conversation_id="s"
+        )
+        assert isinstance(relayed, ParsedMessage) and relayed.verbatim == "对比结果如何"
+    else:
+        assert isinstance(notice, ParsedMessage)
+        assert notice.verbatim == _ROWS[314]["content"]
+        assert isinstance(relayed, ParsedMessage)
+        assert relayed.verbatim == _ROWS[548]["content"]

memhub/apps/core/tests/test_hy_sdk_log_routing.py

@@ -0,0 +1,146 @@
+"""HY SDK text logs go to hy_memory.log only, with warnings also in core.log.
+
+The SDK's first client adds a stdout and a stderr stream to the "hy_memory"
+logger and stops it propagating. Under launchd those streams are
+service.log and service-error.log, so each SDK line used to be written
+twice and none reached core.log.
+"""
+
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from one_memory import hy_sdk_runtime
+from one_memory.log_file import (
+    HY_SDK_LOGGER,
+    confine_hy_sdk_logging,
+    log_path,
+    start_logging_to_file,
+)
+
+
+@pytest.fixture
+def sdk_logger():
+    """The "hy_memory" logger as HY's setup_logging leaves it, restored after."""
+    sdk = logging.getLogger(HY_SDK_LOGGER)
+    root = logging.getLogger()
+    saved = (list(sdk.handlers), sdk.propagate, sdk.level, list(root.handlers), root.level)
+    yield sdk
+    for handler in sdk.handlers:
+        if handler not in saved[0]:
+            handler.close()
+    for handler in root.handlers:
+        if handler not in saved[3]:
+            handler.close()
+    sdk.handlers, sdk.propagate, root.handlers = saved[0], saved[1], saved[3]
+    sdk.setLevel(saved[2])
+    root.setLevel(saved[4])
+
+
+def _configure_like_hy(sdk: logging.Logger, log_dir: Path) -> logging.FileHandler:
+    log_dir.mkdir(parents=True, exist_ok=True)
+    text_log = logging.FileHandler(log_dir / "hy_memory.log", encoding="utf-8")
+    stdout = logging.StreamHandler(sys.stdout)
+    stderr = logging.StreamHandler(sys.stderr)
+    stderr.setLevel(logging.WARNING)
+    sdk.handlers = [text_log, stdout, stderr]
+    sdk.propagate = False
+    sdk.setLevel(logging.INFO)
+    return text_log
+
+
+def test_sdk_lines_stay_in_hy_memory_log_and_warnings_reach_core_log(
+    tmp_path: Path, sdk_logger: logging.Logger
+) -> None:
+    start_logging_to_file(tmp_path)
+    text_log = _configure_like_hy(sdk_logger, tmp_path / "hy")
+
+    confine_hy_sdk_logging()
+    confine_hy_sdk_logging()
+
+    assert not [
+        handler
+        for handler in sdk_logger.handlers
+        if isinstance(handler, logging.StreamHandler)
+        and not isinstance(handler, logging.FileHandler)
+    ]
+    assert text_log in sdk_logger.handlers
+    assert len(sdk_logger.handlers) == 2, "the core.log forwarder is added once"
+
+    child = logging.getLogger("hy_memory.client")
+    child.info("[add] routine sdk line")
+    child.warning("[add] sdk problem")
+    for handler in logging.getLogger().handlers:
+        handler.flush()
+    text_log.flush()
+
+    hy_text = (tmp_path / "hy" / "hy_memory.log").read_text(encoding="utf-8")
+    core_text = log_path(tmp_path).read_text(encoding="utf-8")
+    assert "routine sdk line" in hy_text and "sdk problem" in hy_text
+    assert "sdk problem" in core_text
+    assert "routine sdk line" not in core_text
+    assert core_text.count("sdk problem") == 1
+
+
+def test_nothing_changes_before_hy_has_configured_its_logger(
+    tmp_path: Path, sdk_logger: logging.Logger
+) -> None:
+    start_logging_to_file(tmp_path)
+    sdk_logger.handlers = []
+    sdk_logger.propagate = True
+
+    confine_hy_sdk_logging()
+
+    assert sdk_logger.handlers == []
+
+
+def test_without_core_log_the_streams_are_still_dropped(
+    tmp_path: Path, sdk_logger: logging.Logger
+) -> None:
+    logging.getLogger().handlers = [
+        handler
+        for handler in logging.getLogger().handlers
+        if not isinstance(handler, RotatingFileHandler)
+    ]
+    text_log = _configure_like_hy(sdk_logger, tmp_path / "hy")
+
+    confine_hy_sdk_logging()
+
+    assert sdk_logger.handlers == [text_log]
+
+
+@pytest.mark.parametrize("fails", [False, True])
+def test_every_client_construction_confines_the_sdk_log(
+    tmp_path: Path, monkeypatch, fails: bool
+) -> None:
+    order: list[str] = []
+
+    class Client:
+        def __init__(self, **_options):
+            order.append("client")
+            if fails:
+                raise RuntimeError("construction failed")
+
+    monkeypatch.setattr(hy_sdk_runtime, "HyMemoryClient", Client)
+    monkeypatch.setattr(hy_sdk_runtime, "build_sdk_config", lambda *_a, **_k: SimpleNamespace())
+    monkeypatch.setattr(hy_sdk_runtime, "inspect_graph_width_mismatch", lambda _c: None)
+    monkeypatch.setattr(hy_sdk_runtime, "_acquire_runtime", lambda _c, _k: object())
+    monkeypatch.setattr(hy_sdk_runtime, "_release_runtime", lambda _k: None)
+    monkeypatch.setattr(hy_sdk_runtime, "confine_hy_sdk_logging", lambda: order.append("confine"))
+    profile = SimpleNamespace(embedding_provider_kind=None, provider_kind=None)
+
+    if fails:
+        with pytest.raises(RuntimeError):
+            hy_sdk_runtime._acquire_client(
+                profile, api_key=None, data_dir=tmp_path, http_transport_factory=None
+            )
+    else:
+        hy_sdk_runtime._acquire_client(
+            profile, api_key=None, data_dir=tmp_path, http_transport_factory=None
+        )
+
+    assert order == ["client", "confine"]

memhub/apps/core/tests/test_memory_additions.py

@@ -102,7 +102,7 @@ def test_memory_add_requires_authentication_explicit_scope_and_nonempty_content(
                 {"text": "  \n"},
                 {"text": "x" * 12_001},
                 {"scope": "*"},
-                {"user_id": "other"},
+                {"user_id": "not:a-user"},
             ):
                 assert (
                     await client.post("/api/v2/memories", json={**base, **change})

memhub/apps/core/tests/test_memory_batch_extraction.py

@@ -26,6 +26,7 @@ def snapshot() -> ModelProfileSnapshot:
         base_url="http://127.0.0.1:11434",
         model="memory-model",
         embedding_model="embedding-model",
+        embedding_base_url="http://127.0.0.1:11434",
         embedding_dimensions=768,
         timeout_seconds=30,
         max_concurrency=1,

memhub/apps/core/tests/test_memory_library_all_scenes.py

@@ -6,6 +6,7 @@ and delete pass the memory's kind/variant through to the SDK.
 """
 
 import asyncio
+from contextlib import asynccontextmanager
 
 import pytest
 from httpx import ASGITransport, AsyncClient
@@ -310,12 +311,13 @@ def run_with_sdk(tmp_path, monkeypatch, scenario):
             async def close(self):
                 return None
 
+        @asynccontextmanager
         async def write_client():
-            return sdk
+            yield sdk
 
         async with app.router.lifespan_context(app):
             app.state.sdk_client_handle = Handle()
-            monkeypatch.setattr(app.state.sdk_write_coordinator, "client", write_client)
+            monkeypatch.setattr(app.state.sdk_write_coordinator, "use_client", write_client)
             async with client_for(app) as client:
                 await scenario(app, sdk, client)
 

memhub/apps/core/tests/test_memory_qa.py

@@ -66,6 +66,7 @@ def _grounded_setup(tmp_path, *, memory_id: str = "memory-real-data"):
             base_url="http://127.0.0.1:11434",
             model="test-model",
             embedding_model="test-embedding",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -263,6 +264,7 @@ def test_answer_uses_only_grounded_confirmed_memory_citations(tmp_path) -> None:
             base_url="http://127.0.0.1:11434",
             model="test-model",
             embedding_model="test-embedding",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -468,6 +470,7 @@ def test_answer_rejects_model_citation_outside_retrieved_scope(tmp_path) -> None
             base_url="http://127.0.0.1:11434",
             model="test-model",
             embedding_model="test-embedding",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -530,6 +533,7 @@ def _compatible_gateway_setup(tmp_path):
             base_url="https://api.example.invalid/standard/v1",
             model="deepseek-v4-pro",
             embedding_model="text-embedding",
+            embedding_base_url="https://api.example.invalid/standard/v1",
             api_key="probe-key",
         ),
         secrets,

memhub/apps/core/tests/test_memory_qa_api.py

@@ -56,7 +56,7 @@ def test_sdk_ask_v2_stream_is_native(tmp_path, monkeypatch) -> None:
     )
 
     class Answerer:
-        async def answer_stream(self, _question):
+        async def answer_stream(self, _question, *, user_id="local"):
             yield {"type": "recall", "memories": (memory,)}
             yield {"type": "delta", "text": "你要求真实数据。"}
             yield {

memhub/apps/core/tests/test_memory_qa_permissions.py

@@ -186,6 +186,7 @@ def _setup(tmp_path: Path, *, model: str = "available") -> _Setup:
             base_url="https://memory-qa.example.invalid/v1",
             model="synthetic-generation",
             embedding_model="synthetic-embedding",
+            embedding_base_url="https://memory-qa.example.invalid/v1",
             api_key=SecretStr(_SECRET),
         ),
         secrets,

memhub/apps/core/tests/test_memory_server_durable_queue.py

@@ -1187,6 +1187,167 @@ def test_the_drain_tick_writes_a_quiet_live_conversation(tmp_path, monkeypatch)
     assert flushed
 
 
+class _SwitchableProfiles:
+    """Active profile identity that a test can change mid-write."""
+
+    def __init__(self) -> None:
+        self.identity = ("profile-a", 1)
+
+    def active_identity(self):
+        return self.identity
+
+    def snapshot(self, profile_id, revision):
+        return type(
+            "Snapshot", (), {"profile_id": profile_id, "revision": revision, "has_api_key": False}
+        )()
+
+    def resolve_snapshot_secret(self, *_args):
+        return None
+
+
+class _TrackedHandle:
+    def __init__(self, profile, **_kwargs) -> None:
+        self.profile_id = profile.profile_id
+        self.closed = False
+
+    async def client(self):
+        return self
+
+    async def close(self):
+        self.closed = True
+
+
+def _coordinator(monkeypatch, opened: list[_TrackedHandle]):
+    from one_memory import sdk_write_processor
+
+    def handle(profile, **kwargs):
+        value = _TrackedHandle(profile, **kwargs)
+        opened.append(value)
+        return value
+
+    monkeypatch.setattr(sdk_write_processor, "SdkClientHandle", handle)
+    profiles = _SwitchableProfiles()
+    coordinator = sdk_write_processor.SdkWriteCoordinator(
+        profiles=profiles,  # type: ignore[arg-type]
+        secrets=None,  # type: ignore[arg-type]
+        data_dir=None,
+        transport_factory=lambda _profile: None,
+        sedimentation_enabled=lambda: True,
+    )
+    return coordinator, profiles
+
+
+def test_a_profile_change_does_not_close_the_client_of_a_write_in_flight(monkeypatch) -> None:
+    """Build 35 lost a clean install's first write as unknown (AttributeError).
+
+    Saving a model profile changed the active identity while the write ran on
+    the old profile's client. The next coordinator call closed that client at
+    once: the SDK cleared its stores and the SharedRuntime closed mid-`add`.
+    """
+    from one_memory import sdk_write_processor
+
+    opened: list[_TrackedHandle] = []
+    coordinator, profiles = _coordinator(monkeypatch, opened)
+    seen: list[tuple[str, bool]] = []
+    writing = asyncio.Event()
+
+    async def process(self, records, *, request_id, before_hy_invocation):
+        client = await self._client_handle.client()
+        await before_hy_invocation()
+        seen.append((client.profile_id, client.closed))
+        if client.profile_id == "profile-a":
+            await writing.wait()
+        # Still open while its own write runs.
+        seen.append((client.profile_id, client.closed))
+        return sdk_write_processor.SdkWriteReceipt()
+
+    monkeypatch.setattr(sdk_write_processor.SdkWriteProcessor, "process_sdk_job", process)
+
+    async def noop():
+        return None
+
+    async def scenario():
+        first = asyncio.create_task(
+            coordinator.process_sdk_job((), request_id="a", before_hy_invocation=noop)
+        )
+        while not seen:
+            await asyncio.sleep(0)
+        profiles.identity = ("profile-b", 2)
+        # A second job and an inquiry under the new profile.
+        await coordinator.process_sdk_job((), request_id="b", before_hy_invocation=noop)
+        assert [handle.closed for handle in opened] == [False, False]
+        writing.set()
+        await first
+        old, new = opened
+        # Retired after its last use, and new work used the new profile.
+        assert old.closed is True and new.closed is False
+        await coordinator.close()
+        assert new.closed is True
+
+    asyncio.run(scenario())
+    assert seen == [
+        ("profile-a", False),
+        ("profile-b", False),
+        ("profile-b", False),
+        ("profile-a", False),
+    ]
+
+
+def test_an_unused_stale_handle_still_closes_at_once(monkeypatch) -> None:
+    opened: list[_TrackedHandle] = []
+    coordinator, profiles = _coordinator(monkeypatch, opened)
+
+    async def scenario():
+        async with coordinator.use_client() as client:
+            assert client.profile_id == "profile-a"
+        assert opened[0].closed is False
+        profiles.identity = ("profile-b", 2)
+        async with coordinator.use_client() as client:
+            assert client.profile_id == "profile-b"
+            assert opened[0].closed is True
+        assert opened[1].closed is False
+        await coordinator.close()
+        assert opened[1].closed is True
+
+    asyncio.run(scenario())
+
+
+def test_a_client_that_fails_to_construct_parks_the_job_instead_of_unknown(tmp_path) -> None:
+    """Nothing was sent when the client could not be built, so it retries on its own."""
+    from one_memory.sdk_write_processor import SdkWriteProcessor
+
+    class _BrokenHandle:
+        async def client(self):
+            raise AttributeError("'RustBindingsAPI' object has no attribute 'bindings'")
+
+    path = tmp_path / "one-memory.sqlite3"
+    queue = DurableWriteQueue(path)
+    record = queue.submit(_request())
+    _claim_through_drain(queue, record.job_id)
+
+    class _Supervisor:
+        async def process_sdk_job(self, _records, **kwargs):
+            return await SdkWriteProcessor(_BrokenHandle()).process_sdk_job(  # type: ignore[arg-type]
+                (_sdk_evidence("e1"),), **kwargs
+            )
+
+    asyncio.run(
+        execute_job(
+            record.job_id,
+            queue=queue,
+            supervisor=_Supervisor(),
+            evidence=_EvidenceStore({"e1"}),
+        )
+    )
+
+    [row] = _rows(path)
+    assert (row["state"], row["hy_invoked"]) == (WAITING_FOR_MODEL, 0)
+    assert row["last_error"] == "hy_memory_client_unavailable"
+    later = datetime.now(UTC) + timedelta(minutes=5)
+    assert queue.readmit_model_waiters(now=later) == 1
+    assert _state(path, record.job_id) == PENDING
+
+
 def test_sdk_unknown_outcome_inquiry_uses_only_public_receipt() -> None:
     from one_memory.sdk_write_processor import SdkWriteProcessor, SdkWriteReceipt
 
@@ -1699,6 +1860,46 @@ def test_a_raw_provider_message_is_never_stored_as_the_error(tmp_path) -> None:
     assert stored == "RuntimeError"
 
 
+def test_a_failed_job_logs_where_it_failed_but_never_the_message(tmp_path, caplog) -> None:
+    """`error_code=AttributeError` alone named no location; frames, never the message."""
+    path = tmp_path / "one-memory.sqlite3"
+    queue = DurableWriteQueue(path)
+    record = queue.submit(_request())
+    _claim_through_drain(queue, record.job_id)
+
+    def closed_store(client):
+        return client.private_store_name.write
+
+    class _Failing:
+        async def process_sdk_job(self, _records, **kwargs):
+            await kwargs["before_hy_invocation"]()
+            try:
+                closed_store(type("Client", (), {"private_store_name": None})())
+            except AttributeError as error:
+                raise RuntimeError("quoting 'my secret diary'") from error
+
+    with caplog.at_level(logging.ERROR, logger="one_memory.memory_server.durable_queue"):
+        asyncio.run(
+            execute_job(
+                record.job_id,
+                queue=queue,
+                supervisor=_Failing(),
+                evidence=_EvidenceStore({"e1"}),
+            )
+        )
+
+    [line] = [
+        message.getMessage()
+        for message in caplog.records
+        if "durable_write_job_failed" in message.getMessage()
+    ]
+    assert f"job_id={record.job_id} error_code=RuntimeError chain=RuntimeError@" in line
+    assert ";AttributeError@" in line
+    assert "test_memory_server_durable_queue.py:" in line and ":closed_store" in line
+    assert "secret diary" not in line
+    assert "private_store_name" not in line
+
+
 def test_a_machine_error_code_is_preserved(tmp_path) -> None:
     """Recognised codes survive; only free-form text is dropped."""
     from one_memory.memory_server.durable_queue import safe_error_code

memhub/apps/core/tests/test_memory_task_unknown_retry.py

@@ -25,6 +25,7 @@ def _stores(tmp_path):
             provider_kind=ProviderKind.OLLAMA,
             model="hy-bot-phi4",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )

memhub/apps/core/tests/test_memory_tasks.py

@@ -83,6 +83,7 @@ def test_task_freezes_active_profile_revision_and_is_idempotent(tmp_path) -> Non
             provider_kind=ProviderKind.OLLAMA,
             model="qwen",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -240,6 +241,7 @@ def test_task_extraction_checkpoint_is_idempotent_and_recoverable(tmp_path) -> N
                 provider_kind=ProviderKind.OLLAMA,
                 model="qwen",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),
@@ -293,6 +295,7 @@ def test_task_waits_for_model_and_retries_with_same_snapshot(tmp_path) -> None:
             provider_kind=ProviderKind.OLLAMA,
             model="qwen",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -337,6 +340,7 @@ def test_blocked_stages_name_the_stuck_stage_and_reason(tmp_path) -> None:
                 provider_kind=ProviderKind.OLLAMA,
                 model="qwen",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),
@@ -433,6 +437,7 @@ def test_task_duration_estimate_ignores_time_the_app_was_closed(tmp_path) -> Non
                 provider_kind=ProviderKind.OLLAMA,
                 model="qwen",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),
@@ -537,6 +542,7 @@ def test_running_task_is_recovered_after_worker_restart(tmp_path) -> None:
                 provider_kind=ProviderKind.OLLAMA,
                 model="qwen",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),
@@ -572,6 +578,7 @@ def test_superseded_profile_cancels_only_claimable_tasks(tmp_path) -> None:
                 provider_kind=ProviderKind.OLLAMA,
                 model="phi",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),
@@ -601,6 +608,7 @@ def test_superseded_profile_cancels_only_claimable_tasks(tmp_path) -> None:
                 provider_kind=ProviderKind.OLLAMA,
                 model="qwen",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),
@@ -630,6 +638,7 @@ def test_superseded_ingest_policy_cancels_only_old_conversation_tasks(tmp_path)
                 provider_kind=ProviderKind.OLLAMA,
                 model="qwen",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),
@@ -676,6 +685,7 @@ def test_task_rejects_inactive_profile_and_request_id_reuse(tmp_path) -> None:
             provider_kind=ProviderKind.OLLAMA,
             model="qwen",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -1700,6 +1710,7 @@ def _profile_and_tasks(tmp_path) -> tuple[MemoryTaskStore, ModelProfile]:
                 provider_kind=ProviderKind.OLLAMA,
                 model="qwen",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),
@@ -2058,6 +2069,7 @@ def test_a_failed_task_below_the_ceiling_is_still_claimable(tmp_path) -> None:
                 provider_kind=ProviderKind.OLLAMA,
                 model="qwen",
                 embedding_model="nomic-embed-text",
+                embedding_base_url="http://127.0.0.1:11434",
             ),
             secrets,
         ),

memhub/apps/core/tests/test_memory_visibility.py

@@ -55,6 +55,7 @@ def library(tmp_path):
             provider_kind=ProviderKind.OLLAMA,
             model="hy-bot-phi4",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -611,3 +612,58 @@ def test_granting_a_source_repeatedly_does_not_raise(library):
 
     with main_database_read(database) as db:
         assert memory.memory_id in pending(db)
+
+
+def test_grant_writes_still_work_after_the_cutover_drops_the_link_table(library):
+    """#233: the grant triggers read `governed_memory_evidence`.
+
+    The SDK cutover drops it, and SQLite resolves a trigger body only when it
+    fires, so every grant, revoke and connect then failed with "no such
+    table". A trigger whose body names a missing table is not installed, and
+    the copy an earlier startup installed is dropped.
+    """
+    database, *_ = library
+    from one_memory.imports.candidates import RootCandidateKind
+    from one_memory.imports.grants import SourceGrantStore
+    from one_memory.memory_visibility import drop_stale_triggers
+
+    startup(database)
+    with sqlite3.connect(database) as db:
+        db.execute("DROP TABLE governed_memory_evidence")
+
+    def grant_triggers() -> set[str]:
+        with sqlite3.connect(database) as db:
+            return {
+                str(row[0])
+                for row in db.execute(
+                    "SELECT name FROM sqlite_master "
+                    "WHERE type='trigger' AND tbl_name='source_grants'"
+                )
+            }
+
+    assert grant_triggers() == {
+        "memory_visibility_dirty_on_grants",
+        "memory_visibility_dirty_on_grants_update",
+    }
+    # The `evidence` triggers read the dropped table too; the cutover drops
+    # `evidence` as well, which takes them with it.
+    assert {
+        "memory_visibility_dirty_on_grants",
+        "memory_visibility_dirty_on_grants_update",
+    } <= set(drop_stale_triggers(database))
+    assert grant_triggers() == set()
+    assert drop_stale_triggers(database) == ()
+    # Installing again on this shape skips them instead of bringing them back.
+    startup(database)
+    assert grant_triggers() == set()
+
+    folder = database.parent / "cursor"
+    folder.mkdir(exist_ok=True)
+    store = SourceGrantStore(database, home=database.parent)
+    store.grant(
+        user_id="local",
+        source_id="cursor",
+        root=folder,
+        candidate_kind=RootCandidateKind.DEFAULT,
+    )
+    assert store.revoke(user_id="local", source_id="cursor").revoked_at is not None

memhub/apps/core/tests/test_memory_visibility_equivalence.py

@@ -51,6 +51,7 @@ def library(tmp_path):
             provider_kind=ProviderKind.OLLAMA,
             model="hy-bot-phi4",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )

memhub/apps/core/tests/test_model_probe.py

@@ -28,6 +28,7 @@ def test_probe_still_measures_embedding_when_structured_output_fails(tmp_path) -
             base_url="http://127.0.0.1:11434",
             model="plain-model",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -63,6 +64,7 @@ def test_probe_records_the_real_embedding_width_on_the_profile(tmp_path) -> None
             base_url="http://127.0.0.1:11434",
             model="qwen3:8b",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -119,6 +121,7 @@ def test_openai_compatible_probe_checks_model_and_structured_output(tmp_path) ->
             base_url="https://models.example.com/v1",
             model="memory-model",
             embedding_model="embedding-model",
+            embedding_base_url="https://models.example.com/v1",
             api_key=SecretStr(API_KEY),
         ),
         secrets,
@@ -260,6 +263,7 @@ def test_probe_reports_missing_model_without_sending_generation(tmp_path) -> Non
             provider_kind=ProviderKind.OLLAMA,
             model="memory-model",
             embedding_model="embedding-model",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )

memhub/apps/core/tests/test_model_profile_api.py

@@ -50,6 +50,7 @@ def test_model_profile_api_never_returns_key_and_enforces_revision(tmp_path) ->
                     "base_url": "https://models.example.com/v1",
                     "model": "memory-model",
                     "embedding_model": "embedding-model",
+                    "embedding_base_url": "https://models.example.com/v1",
                     "api_key": API_KEY,
                 },
             )
@@ -134,6 +135,7 @@ def test_model_profile_probe_route_returns_only_machine_results(tmp_path) -> Non
                     "base_url": "https://models.example.com/v1",
                     "model": "memory-model",
                     "embedding_model": "embedding-model",
+                    "embedding_base_url": "https://models.example.com/v1",
                     "api_key": API_KEY,
                 },
             )
@@ -244,6 +246,7 @@ def test_activation_survives_a_corpus_already_imported(tmp_path) -> None:
                     "base_url": "https://models.example.com/v1",
                     "model": "memory-model",
                     "embedding_model": "embedding-model",
+                    "embedding_base_url": "https://models.example.com/v1",
                     "api_key": API_KEY,
                 },
             )

memhub/apps/core/tests/test_model_profiles.py

@@ -198,6 +198,7 @@ def test_active_profile_can_be_deleted_without_changing_other_profiles(tmp_path)
             provider_kind=ProviderKind.OLLAMA,
             model="other",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -208,6 +209,7 @@ def test_active_profile_can_be_deleted_without_changing_other_profiles(tmp_path)
             base_url="https://models.example.com/v1",
             model="qwen",
             embedding_model="nomic-embed-text",
+            embedding_base_url="https://models.example.com/v1",
             api_key=SecretStr(API_KEY),
         ),
         secrets,
@@ -349,6 +351,7 @@ def _probed(store, secrets, *, structured: bool, generates: bool = True):
             provider_kind=ProviderKind.OLLAMA,
             model="qwen",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )
@@ -394,3 +397,102 @@ def test_a_model_that_cannot_generate_still_cannot_be_turned_on(tmp_path) -> Non
 
     with pytest.raises(ModelProfileUnavailableError):
         store.activate(profile.profile_id, secrets)
+
+
+def _space(store: ModelProfileStore, profile_id: str) -> str:
+    """The embedding space's collection base, as the Runtime names it."""
+    from one_memory.hy_sdk_runtime import vector_collection_bases
+
+    identity = (profile_id, store.require(profile_id, InMemorySecretStore()).revision)
+    return vector_collection_bases(store.snapshot(*identity))[0]
+
+
+def test_a_remote_embedding_must_name_its_endpoint(tmp_path) -> None:
+    """The endpoint no longer follows the generation `base_url`."""
+    from one_memory.model_profiles import EmbeddingBaseUrlRequiredError
+
+    store = ModelProfileStore(tmp_path / "one-memory.sqlite3")
+    secrets = InMemorySecretStore()
+    unnamed = ModelProfileInput(
+        name="Remote",
+        provider_kind=ProviderKind.OPENAI_COMPATIBLE,
+        base_url="https://models.example.com/v1",
+        model="qwen",
+        embedding_model="text-embedding-3-small",
+        api_key=SecretStr(API_KEY),
+    )
+    with pytest.raises(EmbeddingBaseUrlRequiredError):
+        store.create(unnamed, secrets)
+    assert store.list(secrets) == []
+
+    named = store.create(
+        unnamed.model_copy(update={"embedding_base_url": "https://models.example.com/v1"}),
+        secrets,
+    )
+    with pytest.raises(EmbeddingBaseUrlRequiredError):
+        store.update(
+            named.profile_id,
+            ModelProfilePatch(
+                expected_revision=named.revision,
+                embedding_provider_kind=ProviderKind.OLLAMA,
+                embedding_base_url="",
+            ),
+            secrets,
+        )
+
+
+def test_stored_profiles_get_the_endpoint_they_resolved_to_and_keep_their_space(
+    tmp_path,
+) -> None:
+    """An older build stored remote embeddings with a NULL endpoint and resolved
+    it to the generation `base_url` at runtime. Opening the store writes that
+    endpoint in once, so the collection, and the memories in it, stay put; a
+    later edit of the generation endpoint no longer moves them.
+    """
+    from one_memory.hy_sdk_runtime import vector_collection_bases
+
+    database = tmp_path / "one-memory.sqlite3"
+    store = ModelProfileStore(database)
+    secrets = InMemorySecretStore()
+    profile = store.create(
+        ModelProfileInput(
+            name="Remote",
+            provider_kind=ProviderKind.OPENAI_COMPATIBLE,
+            base_url="https://gateway.example.com/v1",
+            model="qwen",
+            embedding_model="text-embedding-3-small",
+            embedding_base_url="https://gateway.example.com/v1",
+            embedding_dimensions=1536,
+            api_key=SecretStr(API_KEY),
+        ),
+        secrets,
+    )
+    identity = (profile.profile_id, profile.revision)
+    # The space the older build's Runtime resolved: `embedding_base_url or base_url`.
+    before = vector_collection_bases(store.snapshot(*identity))[0]
+    with sqlite3.connect(database) as db:
+        # The shape an older build stored.
+        db.execute("UPDATE model_profiles SET embedding_base_url=NULL")
+        db.execute("UPDATE model_profile_versions SET embedding_base_url=NULL")
+
+    migrated = ModelProfileStore(database)
+    assert migrated.snapshot(*identity).embedding_base_url == "https://gateway.example.com/v1"
+    assert _space(migrated, profile.profile_id) == before
+    # Idempotent: opening again changes nothing.
+    assert _space(ModelProfileStore(database), profile.profile_id) == before
+    with sqlite3.connect(database) as db:
+        assert db.execute(
+            "SELECT COUNT(*) FROM model_profile_versions WHERE embedding_base_url IS NULL"
+        ).fetchone() == (0,)
+
+    edited = migrated.update(
+        profile.profile_id,
+        ModelProfilePatch(
+            expected_revision=profile.revision,
+            base_url="https://gateway.example.com/eu/v1",
+        ),
+        secrets,
+    )
+    assert edited.base_url == "https://gateway.example.com/eu/v1"
+    assert edited.embedding_base_url == "https://gateway.example.com/v1"
+    assert _space(migrated, profile.profile_id) == before

memhub/apps/core/tests/test_multi_user_runtime.py

@@ -0,0 +1,858 @@
+"""One Runtime, many users: `user_id` on the memory API, per-user Hermes profiles.
+
+A user is the root that is read (a Hermes profile's own `state.db`), never a
+session or platform field. The App never names a user and keeps `local`;
+every other harness stays on `local`. These tests drive the production app
+against a user-aware stand-in for the public SDK client, whose `get`,
+`update` and `delete` take no user exactly like hy-memory 2.0.9's.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sqlite3
+from contextlib import asynccontextmanager
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from uuid import uuid4
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+from pydantic import SecretStr
+
+from one_memory.api import _sdk_recall_target, create_app
+from one_memory.config import Settings
+from one_memory.imports.access import AuthorizedSourceRoot
+from one_memory.imports.adapters import ScannedEvidence, ScanOptions
+from one_memory.imports.models import (
+    EvidenceInput,
+    EvidenceOrigin,
+    OriginMetadata,
+    WrittenBy,
+    materialize_write_input,
+)
+from one_memory.imports.sources.hermes import HERMES_DESCRIPTOR, create_hermes_adapter
+from one_memory.imports.sources.registry import build_source_catalog
+from one_memory.memory_server.contracts import internal_session_id_for
+from one_memory.memory_server.durable_queue import (
+    DurableWriteDrain,
+    DurableWriteQueue,
+    execute_job,
+)
+from one_memory.sdk_write_processor import SdkWriteProcessor
+from one_memory.secrets import InMemorySecretStore
+from one_memory.user_scope import lane_key, split_lane, valid_user_id
+
+TOKEN = "multi-user-test"
+
+
+class UserAwareSdk:
+    """The public client surface MemHub calls, holding memories per user."""
+
+    def __init__(self) -> None:
+        self.memories: dict[str, dict[str, object]] = {}
+        self.add_calls: list[dict[str, object]] = []
+
+    def _store(self, user_id: str, content: str, *, source: str, session_id: str) -> str:
+        memory_id = f"memory-{len(self.memories) + 1}"
+        self.memories[memory_id] = {
+            "memory_id": memory_id,
+            "content": content,
+            "layer": "l2_fact",
+            "status": "active",
+            "user_id": user_id,
+            "agent_id": "all-apps",
+            "session_id": session_id,
+            "source": source,
+            "tags": [],
+            "gmt_created": 1_790_000_000,
+        }
+        return memory_id
+
+    def add(self, messages, *, user_id, session_id, source, request_id, **_kwargs):
+        self.add_calls.append({"user_id": user_id, "request_id": request_id})
+        text = " ".join(item["content"] for item in messages if item["role"] == "user")
+        memory_id = self._store(user_id, text, source=source, session_id=session_id)
+        return {"success": True, "memory_ids": [memory_id]}
+
+    def add_extracted(self, contents, *, user_id, session_id, source, request_id, **_kwargs):
+        self.add_calls.append({"user_id": user_id, "request_id": request_id})
+        memory_id = self._store(user_id, " ".join(contents), source=source, session_id=session_id)
+        return {"success": True, "memory_ids": [memory_id]}
+
+    def _rows(self, user_ids) -> list[dict[str, object]]:
+        return [dict(row) for row in self.memories.values() if row["user_id"] in user_ids]
+
+    def list_memories(self, *, user_id, scene=None, offset=0, limit=100, **_kwargs):
+        rows = [] if _kwargs.get("layers") == ["l1_raw"] else self._rows({user_id})
+        page = rows[offset : offset + limit]
+        if scene == "all":
+            return {
+                "scene": "all",
+                "memories": [{**row, "scene": "chat", "kind": "chat"} for row in page],
+                "total": len(rows),
+                "totals": {"chat": len(rows), "working": 0, "coding": 0},
+                "errors": {},
+                "limit": limit,
+                "offset": offset,
+                "request_id": "list",
+                "elapsed_ms": 1.0,
+            }
+        return {"vdb": {"memories": page, "total": len(rows), "limit": limit, "offset": offset}}
+
+    def memory_stats(self, *, user_id, statuses=None):
+        return {"total": len(self._rows({user_id})), "request_id": "stats", "elapsed_ms": 1.0}
+
+    def search(self, query, *, user_ids, scene=None, **kwargs):
+        rows = [] if kwargs.get("layers") == ["l1_raw"] else self._rows(set(user_ids))
+        items = [{**row, "scene": "chat", "kind": "chat", "score": 0.9} for row in rows]
+        if scene == "all":
+            return {
+                "request_id": "search",
+                "scene": "all",
+                "memories": items,
+                "lanes": {"chat": len(items), "working": 0, "coding": 0},
+                "errors": {},
+                "elapsed_ms": 1.0,
+            }
+        return {"request_id": "search", "scene": scene or "normal", "memories": items}
+
+    def get(self, memory_id, kind=None, variant=None):
+        row = self.memories.get(memory_id)
+        return None if row is None else {**row, "kind": "chat", "variant": None}
+
+    def update(self, memory_id, content, kind=None, variant=None, task=None):
+        if memory_id not in self.memories:
+            return {"success": False, "error_message": f"memory_id '{memory_id}' not found"}
+        self.memories[memory_id]["content"] = content
+        return {"success": True, "memory_id": memory_id}
+
+    def delete(self, memory_id, kind=None, variant=None):
+        if self.memories.pop(memory_id, None) is None:
+            return {"success": False, "deleted_count": 0}
+        return {"success": True, "deleted_count": 1}
+
+    def get_user_profile(self, *, user_id):
+        return {
+            "request_id": f"profile-{user_id}",
+            "profile": {
+                "memory_id": f"l0-{user_id}",
+                "content": f"name is {user_id}",
+                "layer": "L0_BASIC_INFO",
+                "basic_info": {"name": user_id},
+            },
+            "elapsed_ms": 1.0,
+        }
+
+
+class Handle:
+    def __init__(self, sdk: UserAwareSdk) -> None:
+        self.sdk = sdk
+
+    async def client(self) -> UserAwareSdk:
+        return self.sdk
+
+    async def close(self) -> None:
+        return None
+
+
+class Coordinator:
+    """The production write processor over the stand-in client."""
+
+    def __init__(self, sdk: UserAwareSdk) -> None:
+        self.processor = SdkWriteProcessor(Handle(sdk))  # type: ignore[arg-type]
+
+    async def process_sdk_job(self, records, *, request_id, before_hy_invocation):
+        return await self.processor.process_sdk_job(
+            records, request_id=request_id, before_hy_invocation=before_hy_invocation
+        )
+
+
+async def _never(_job_id: str) -> None:
+    return None
+
+
+async def drain_all(queue: DurableWriteQueue, sdk: UserAwareSdk) -> None:
+    """Claim and run every pending job, ungated, the way the drain would."""
+    drain = DurableWriteDrain(queue, execute=_never, lease=timedelta(seconds=30))
+    while claimed := drain.claim(limit=8):
+        for job_id in claimed:
+            await execute_job(
+                job_id,
+                queue=queue,
+                supervisor=Coordinator(sdk),
+                evidence=None,  # type: ignore[arg-type]
+            )
+
+
+def application(tmp_path: Path, *, home: Path | None = None):
+    """The production app; with `home`, imports run over that home's sources."""
+    settings = Settings(
+        data_dir=tmp_path / "data",
+        source_home=home or tmp_path,
+        api_token=SecretStr(TOKEN),
+        imports_enabled=home is not None,
+        automatic_memory_processing=False,
+        live_sync_enabled=False,
+    )
+    return create_app(
+        settings,
+        secret_store=InMemorySecretStore(),
+        source_catalog=(
+            build_source_catalog(home=home, environment={}, platform="darwin")
+            if home is not None
+            else None
+        ),
+    )
+
+
+def client_for(app) -> AsyncClient:
+    return AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test",
+        headers={"Authorization": f"Bearer {TOKEN}"},
+    )
+
+
+def run_with_sdk(tmp_path, monkeypatch, scenario) -> None:
+    async def main() -> None:
+        app = application(tmp_path)
+        sdk = UserAwareSdk()
+
+        @asynccontextmanager
+        async def write_client():
+            yield sdk
+
+        async with app.router.lifespan_context(app):
+            app.state.sdk_client_handle = Handle(sdk)
+            monkeypatch.setattr(app.state.sdk_write_coordinator, "use_client", write_client)
+            async with client_for(app) as client:
+                await scenario(app, sdk, client)
+
+    asyncio.run(main())
+
+
+def _messages(text: str) -> list[dict[str, str]]:
+    return [{"role": "user", "content": text}, {"role": "assistant", "content": "noted"}]
+
+
+async def _write_both_users(app, sdk, client) -> dict[str, str]:
+    """`local` and `wife` each add one memory and submit one conversation."""
+    receipts = {}
+    for user, word in (("local", "tea"), ("wife", "coffee")):
+        request_id = str(uuid4())
+        body = {"request_id": request_id, "text": f"{user} drinks {word}", "scope": "all-apps"}
+        if user != "local":
+            body["user_id"] = user
+        added = await client.post("/api/v2/memories", json=body)
+        assert added.status_code == 201, added.text
+        receipts[f"add:{user}"] = request_id
+        write = {
+            "request_id": "same-request-id",
+            "session_id": "same-session",
+            "source_id": "one-memory-manual",
+            "messages": _messages(f"{user} walks the {word} route"),
+        }
+        if user != "local":
+            write["user_id"] = user
+        written = await client.post("/api/v2/memory-writes", json=write)
+        assert written.status_code == 202, written.text
+        assert written.json()["request_id"] == "same-request-id"
+    await drain_all(app.state.memory_write_queue, sdk)
+    return receipts
+
+
+def _contents(page: dict) -> set[str]:
+    return {memory["content"] for memory in page["memories"]}
+
+
+@pytest.mark.fresh_sdk
+def test_each_user_reads_only_their_own_library_search_profile_and_graph(
+    tmp_path, monkeypatch
+) -> None:
+    async def scenario(app, sdk, client):
+        await _write_both_users(app, sdk, client)
+        assert {call["user_id"] for call in sdk.add_calls} == {"local", "wife"}
+        # The same caller request id from two users is two SDK requests.
+        assert len({call["request_id"] for call in sdk.add_calls}) == len(sdk.add_calls) == 4
+
+        local = (await client.get("/api/v2/memory-library")).json()
+        wife = (await client.get("/api/v2/memory-library", params={"user_id": "wife"})).json()
+        assert _contents(local) == {"local drinks tea", "local walks the tea route"}
+        assert _contents(wife) == {"wife drinks coffee", "wife walks the coffee route"}
+        nobody = await client.get("/api/v2/memory-library", params={"user_id": "__nobody__"})
+        assert nobody.status_code == 200 and nobody.json()["memories"] == []
+
+        searched = (
+            await client.get("/api/v2/memory-library", params={"query": "route", "user_id": "wife"})
+        ).json()
+        assert _contents(searched) == {"wife walks the coffee route"}
+
+        context = await client.post(
+            "/api/v2/context/search",
+            json={"query": "drinks", "kinds": ["memory"], "user_id": "wife"},
+        )
+        assert context.status_code == 200, context.text
+        assert {item["content"] for item in context.json()["items"]} == {
+            "wife drinks coffee",
+            "wife walks the coffee route",
+        }
+        local_context = await client.post(
+            "/api/v2/context/search", json={"query": "drinks", "kinds": ["memory"]}
+        )
+        assert all("wife" not in item["content"] for item in local_context.json()["items"])
+
+        profile = (await client.get("/api/v2/user-profile", params={"user_id": "wife"})).json()
+        assert profile["profile"]["basic_info"] == {"name": "wife"}
+        assert (await client.get("/api/v2/user-profile")).json()["profile"]["basic_info"] == {
+            "name": "local"
+        }
+
+        graph = (await client.get("/api/v2/memories/graph", params={"user_id": "wife"})).json()
+        labels = {node["label"] for node in graph["nodes"] if node["node_type"] == "memory"}
+        assert labels == {"wife drinks coffee", "wife walks the coffee route"}
+
+        summary = (await client.get("/api/v2/home-summary", params={"user_id": "wife"})).json()
+        assert summary["memory_count"] == 2
+
+    run_with_sdk(tmp_path, monkeypatch, scenario)
+
+
+@pytest.mark.fresh_sdk
+def test_another_users_memory_id_answers_404_for_read_update_and_delete(
+    tmp_path, monkeypatch
+) -> None:
+    async def scenario(app, sdk, client):
+        await _write_both_users(app, sdk, client)
+        [wife_memory] = [
+            memory_id
+            for memory_id, row in sdk.memories.items()
+            if row["user_id"] == "wife" and row["content"] == "wife drinks coffee"
+        ]
+        path = f"/api/v2/memories/{wife_memory}"
+
+        assert (await client.get(path)).status_code == 404
+        assert (await client.put(path, json={"content": "stolen"})).status_code == 404
+        assert (await client.delete(path)).status_code == 204
+        assert sdk.memories[wife_memory]["content"] == "wife drinks coffee"
+
+        own = await client.get(path, params={"user_id": "wife"})
+        assert own.status_code == 200 and own.json()["user_id"] == "wife"
+        updated = await client.put(path, json={"content": "wife drinks tea", "user_id": "wife"})
+        assert updated.status_code == 200
+        assert (await client.delete(path, params={"user_id": "wife"})).status_code == 204
+        assert wife_memory not in sdk.memories
+
+    run_with_sdk(tmp_path, monkeypatch, scenario)
+
+
+@pytest.mark.fresh_sdk
+def test_receipts_belong_to_the_user_that_submitted_them(tmp_path, monkeypatch) -> None:
+    async def scenario(app, sdk, client):
+        receipts = await _write_both_users(app, sdk, client)
+        wife_add = f"/api/v2/memories/additions/{receipts['add:wife']}"
+        assert (await client.get(wife_add)).status_code == 404
+        own = await client.get(wife_add, params={"user_id": "wife"})
+        assert own.status_code == 200 and own.json()["state"] == "ready"
+        local_add = f"/api/v2/memories/additions/{receipts['add:local']}"
+        assert (await client.get(local_add, params={"user_id": "wife"})).status_code == 404
+
+        # Both users used `same-request-id`; each reads only their own receipt.
+        local_write = await client.get("/api/v2/memory-writes/same-request-id")
+        wife_write = await client.get(
+            "/api/v2/memory-writes/same-request-id", params={"user_id": "wife"}
+        )
+        assert local_write.status_code == wife_write.status_code == 200
+        assert local_write.json()["memory_ids"] != wife_write.json()["memory_ids"]
+        assert (
+            await client.get("/api/v2/memory-writes/same-request-id", params={"user_id": "kid"})
+        ).status_code == 404
+        # `local` cannot name another user's namespaced queue key directly.
+        with sqlite3.connect(app.state.settings.data_dir / "one-memory.sqlite3") as db:
+            keys = [row[0] for row in db.execute("SELECT idempotency_key FROM memory_write_jobs")]
+        wife_key = next(key for key in keys if key.startswith("user:wife:"))
+        assert (await client.get(f"/api/v2/memory-writes/{wife_key}")).status_code == 404
+
+    run_with_sdk(tmp_path, monkeypatch, scenario)
+
+
+@pytest.mark.fresh_sdk
+def test_omitting_user_id_keeps_local_and_recall_and_ask_pass_it_through(
+    tmp_path, monkeypatch
+) -> None:
+    async def scenario(app, sdk, client):
+        await _write_both_users(app, sdk, client)
+        seen: list[str] = []
+        original = sdk.list_memories
+
+        def recording(**kwargs):
+            seen.append(kwargs["user_id"])
+            return original(**kwargs)
+
+        sdk.list_memories = recording  # type: ignore[method-assign]
+        # Built at startup over the real handle; rebuilt here over the stand-in.
+        app.state.recall_target = _sdk_recall_target(app, "local")
+        await client.get("/api/v2/memory-library")
+        await client.get("/api/v2/raw")
+        await client.get("/api/v2/home-summary")
+        assert set(seen) == {"local"}
+
+        monkeypatch.setattr(
+            "one_memory.api._recall_model_ready", lambda _app: _true(), raising=True
+        )
+        recalled = await client.post("/api/v1/recall", json={"query": "drinks", "user_id": "wife"})
+        assert recalled.status_code == 200, recalled.text
+        assert {hit["content"] for hit in recalled.json()["hits"]} == {
+            "wife drinks coffee",
+            "wife walks the coffee route",
+        }
+        local = await client.post("/api/v1/recall", json={"query": "drinks"})
+        assert all("wife" not in hit["content"] for hit in local.json()["hits"])
+
+        answered = await client.post(
+            "/api/v2/memories/ask", json={"question": "what does she drink", "user_id": "wife"}
+        )
+        assert answered.status_code == 200, answered.text
+        assert {memory["content"] for memory in answered.json()["memories"]} <= {
+            "wife drinks coffee",
+            "wife walks the coffee route",
+        }
+
+    run_with_sdk(tmp_path, monkeypatch, scenario)
+
+
+async def _true() -> bool:
+    return True
+
+
+@pytest.mark.fresh_sdk
+@pytest.mark.parametrize(
+    ("method", "path", "kwargs"),
+    [
+        ("get", "/api/v2/memory-library", {"params": {"nobody": "1"}}),
+        ("get", "/api/v2/home-summary", {"params": {"userid": "wife"}}),
+        ("get", "/api/v2/user-profile", {"params": {"user": "wife"}}),
+        ("get", "/api/v2/raw", {"params": {"scope": "x"}}),
+        ("get", "/api/v2/memories/graph", {"params": {"scene": "all"}}),
+        ("get", "/api/v2/memories/some-id", {"params": {"owner": "wife"}}),
+        ("delete", "/api/v2/memories/some-id", {"params": {"owner": "wife"}}),
+        ("get", "/api/v2/memory-writes/some-id", {"params": {"owner": "wife"}}),
+        ("get", f"/api/v2/memories/additions/{uuid4()}", {"params": {"owner": "wife"}}),
+        ("post", "/api/v2/memories/ask", {"json": {"question": "q", "user": "wife"}}),
+        ("post", "/api/v1/recall", {"json": {"query": "q", "user": "wife"}}),
+        ("post", "/api/v1/recall", {"json": {"query": "q"}, "params": {"user_id": "wife"}}),
+        ("post", "/api/v2/context/search", {"json": {"query": "q", "owner": "wife"}}),
+        (
+            "post",
+            "/api/v2/memories",
+            {"json": {"request_id": str(uuid4()), "text": "t", "scope": "all-apps", "u": 1}},
+        ),
+        ("put", "/api/v2/memories/some-id", {"json": {"content": "c", "owner": "wife"}}),
+    ],
+)
+def test_unknown_query_and_body_parameters_answer_422(tmp_path, method, path, kwargs) -> None:
+    async def scenario():
+        app = application(tmp_path)
+        async with app.router.lifespan_context(app), client_for(app) as client:
+            response = await client.request(method.upper(), path, **kwargs)
+            assert response.status_code == 422, response.text
+            assert response.json()["detail"] == "request_validation_failed"
+
+    asyncio.run(scenario())
+
+
+@pytest.mark.fresh_sdk
+@pytest.mark.parametrize("bad", ["a:b", "", "x" * 65, "white space", "ü", "a/b"])
+def test_a_malformed_user_id_answers_422(tmp_path, bad) -> None:
+    async def scenario():
+        app = application(tmp_path)
+        async with app.router.lifespan_context(app), client_for(app) as client:
+            responses = [
+                await client.get("/api/v2/memory-library", params={"user_id": bad}),
+                await client.get("/api/v2/user-profile", params={"user_id": bad}),
+                await client.post(
+                    "/api/v2/memories",
+                    json={
+                        "request_id": str(uuid4()),
+                        "text": "t",
+                        "scope": "all-apps",
+                        "user_id": bad,
+                    },
+                ),
+                await client.post(
+                    "/api/v2/memory-writes",
+                    json={
+                        "request_id": "r",
+                        "session_id": "s",
+                        "messages": _messages("hello"),
+                        "user_id": bad,
+                    },
+                ),
+                await client.post("/api/v1/recall", json={"query": "q", "user_id": bad}),
+            ]
+            assert [response.status_code for response in responses] == [422] * len(responses)
+
+    asyncio.run(scenario())
+
+
+def test_user_ids_and_lanes() -> None:
+    assert valid_user_id("wife") and valid_user_id("A.b_c-9")
+    assert not valid_user_id("a:b") and not valid_user_id("wife\n")
+    assert lane_key("local", "hermes") == "hermes"
+    assert lane_key("wife", "hermes") == "hermes@wife"
+    assert split_lane("hermes@wife") == ("wife", "hermes")
+    assert split_lane("hermes") == ("local", "hermes")
+    # `local` keeps the session identity it always had; another user's never equals it.
+    assert internal_session_id_for("s-1", "hermes") == "s-1"
+    assert internal_session_id_for("s-1", "hermes", "wife") != "s-1"
+    assert internal_session_id_for("s-1", "hermes", "wife") != internal_session_id_for(
+        "s-1", "hermes", "kid"
+    )
+
+
+def _hermes_state_db(root: Path, rows: list[tuple[int, str, str, str]]) -> None:
+    root.mkdir(parents=True, exist_ok=True)
+    connection = sqlite3.connect(root / "state.db")
+    connection.execute(
+        "CREATE TABLE messages (id INTEGER PRIMARY KEY, session_id TEXT, role TEXT,"
+        " content TEXT, timestamp REAL, tool_name TEXT, active INTEGER)"
+    )
+    connection.executemany(
+        "INSERT INTO messages VALUES (?, ?, ?, ?, 1790000000, NULL, 1)",
+        rows,
+    )
+    connection.commit()
+    connection.close()
+
+
+def _hermes_homes(home: Path) -> tuple[Path, Path]:
+    hermes = home / ".hermes"
+    wife = hermes / "profiles" / "wife"
+    # The same Hermes session id in both profiles: identities must not merge.
+    _hermes_state_db(
+        hermes,
+        [(1, "session-1", "user", "I am the husband"), (2, "session-1", "assistant", "hi")],
+    )
+    _hermes_state_db(
+        wife,
+        [(1, "session-1", "user", "I am the wife"), (2, "session-1", "assistant", "hello")],
+    )
+    return hermes, wife
+
+
+def _scan_texts(root: Path, home: Path) -> list[str]:
+    adapter = create_hermes_adapter(
+        AuthorizedSourceRoot.grant(
+            source_id=HERMES_DESCRIPTOR.source_id, root=root, user_confirmed=True, home=home
+        )
+    )
+
+    async def collect() -> list[str]:
+        return [
+            event.evidence.verbatim
+            async for event in adapter.scan(ScanOptions(cursors={}))
+            if isinstance(event, ScannedEvidence)
+        ]
+
+    return asyncio.run(collect())
+
+
+def test_a_hermes_root_scan_never_reads_its_profiles(tmp_path) -> None:
+    hermes, wife = _hermes_homes(tmp_path)
+    (hermes / "profiles" / "wife" / "sessions").mkdir()
+    (hermes / "profiles" / "wife" / "sessions" / "s.jsonl").write_text(
+        json.dumps({"type": "message", "role": "user", "content": "wife's transcript"}) + "\n"
+    )
+
+    assert _scan_texts(hermes, tmp_path) == ["I am the husband", "hi"]
+    assert _scan_texts(wife, tmp_path) == ["I am the wife", "hello", "wife's transcript"]
+
+
+def _jobs(database: Path) -> list[sqlite3.Row]:
+    with sqlite3.connect(database) as db:
+        db.row_factory = sqlite3.Row
+        return db.execute(
+            "SELECT session_key,source_key,idempotency_key,state,payload_json "
+            "FROM memory_write_jobs ORDER BY queue_seq"
+        ).fetchall()
+
+
+@pytest.mark.fresh_sdk
+def test_two_hermes_grants_each_read_their_own_root_into_separate_batches(tmp_path) -> None:
+    async def scenario():
+        home = tmp_path / "home"
+        _hermes, wife = _hermes_homes(home)
+        app = application(tmp_path, home=home)
+        async with app.router.lifespan_context(app), client_for(app) as client:
+            location = (await client.post("/api/v1/sources/hermes/location")).json()
+            local = await client.post(
+                "/api/v1/sources/connect",
+                json={
+                    "source_ids": ["hermes"],
+                    "request_id": str(uuid4()),
+                    "source_roots": {"hermes": location["root_id"]},
+                    "enable_sync": True,
+                },
+            )
+            assert local.status_code == 200, local.text
+            profile = await client.post(
+                "/api/v1/sources/connect",
+                json={
+                    "source_ids": ["hermes"],
+                    "request_id": str(uuid4()),
+                    "user_id": "wife",
+                    "root": str(wife),
+                },
+            )
+            assert profile.status_code == 200, profile.text
+            [wife_job] = profile.json()["jobs"]
+            assert wife_job["user_id"] == "wife"
+            jobs = [*local.json()["jobs"], wife_job]
+            for job in jobs:
+                finished = await app.state.import_supervisor.wait(job["job_id"])
+                assert finished.status == "completed", finished
+
+            rows = [row for row in _jobs(app.state.settings.data_dir / "one-memory.sqlite3")]
+            assert rows, "history import wrote no batches"
+            by_user: dict[str, list[str]] = {}
+            for row in rows:
+                records = json.loads(row["payload_json"])["input_records"]
+                users = {record["user_id"] for record in records}
+                assert len(users) == 1, "a batch mixed users"
+                [user] = users
+                by_user.setdefault(user, []).extend(record["verbatim"] for record in records)
+                assert row["source_key"] == lane_key(user, "hermes")
+                assert row["session_key"] == internal_session_id_for("session-1", "hermes", user)
+            assert sorted(by_user["local"]) == ["I am the husband", "hi"]
+            assert sorted(by_user["wife"]) == ["I am the wife", "hello"]
+
+            grants = (await client.get("/api/v1/source-grants")).json()["grants"]
+            assert {(grant["user_id"], grant["source_id"]) for grant in grants} >= {
+                ("local", "hermes"),
+                ("wife", "hermes"),
+            }
+            # The App's view stays `local`'s.
+            listed = (await client.get("/api/v1/import-jobs")).json()
+            assert {job["user_id"] for job in listed} == {"local"}
+            wife_jobs = (await client.get("/api/v1/import-jobs", params={"user_id": "wife"})).json()
+            assert {job["user_id"] for job in wife_jobs} == {"wife"}
+            assert all(
+                item["source_id"] != "hermes@wife"
+                for item in (await client.get("/api/v1/live-sync")).json()
+            )
+
+            revoked = await client.post("/api/v1/sources/hermes/revoke", params={"user_id": "wife"})
+            assert revoked.status_code == 200 and revoked.json()["revoked_at"] is not None
+            local_grant = app.state.source_grant_store.receipt(user_id="local", source_id="hermes")
+            assert local_grant.revoked_at is None
+
+    asyncio.run(scenario())
+
+
+@pytest.mark.fresh_sdk
+def test_a_migrated_home_with_the_old_grant_triggers_can_connect_and_revoke(tmp_path) -> None:
+    """#233: a home an earlier build migrated kept two `source_grants` triggers
+    whose body reads the dropped `governed_memory_evidence`. Every grant write
+    then failed, so connecting and revoking answered 503. Startup drops them.
+    """
+    stale = """
+        CREATE TRIGGER memory_visibility_dirty_on_grants{suffix}
+        AFTER {event} ON source_grants
+        BEGIN
+            INSERT INTO memory_visibility_dirty (memory_id)
+            SELECT DISTINCT link.memory_id
+            FROM governed_memory_evidence link
+            JOIN evidence e ON e.evidence_id = link.evidence_id
+            WHERE e.source_id = NEW.source_id
+            ON CONFLICT(memory_id) DO NOTHING;
+        END;"""
+
+    async def scenario():
+        home = tmp_path / "home"
+        _hermes, wife = _hermes_homes(home)
+        app = application(tmp_path, home=home)
+        async with app.router.lifespan_context(app):
+            database = app.state.settings.data_dir / "one-memory.sqlite3"
+        with sqlite3.connect(database) as db:
+            db.execute("CREATE TABLE IF NOT EXISTS memory_visibility_dirty (memory_id TEXT)")
+            db.execute(stale.format(suffix="", event="INSERT"))
+            db.execute(stale.format(suffix="_update", event="UPDATE"))
+
+        app = application(tmp_path, home=home)
+        async with app.router.lifespan_context(app), client_for(app) as client:
+            location = (await client.post("/api/v1/sources/hermes/location")).json()
+            local = await client.post(
+                "/api/v1/sources/connect",
+                json={
+                    "source_ids": ["hermes"],
+                    "request_id": str(uuid4()),
+                    "source_roots": {"hermes": location["root_id"]},
+                },
+            )
+            assert local.status_code == 200, local.text
+            profile = await client.post(
+                "/api/v1/sources/connect",
+                json={
+                    "source_ids": ["hermes"],
+                    "request_id": str(uuid4()),
+                    "user_id": "wife",
+                    "root": str(wife),
+                },
+            )
+            assert profile.status_code == 200, profile.text
+            for user_id in ("wife", "local"):
+                revoked = await client.post(
+                    "/api/v1/sources/hermes/revoke", params={"user_id": user_id}
+                )
+                assert revoked.status_code == 200, revoked.text
+                assert revoked.json()["revoked_at"] is not None
+        with sqlite3.connect(database) as db:
+            assert (
+                db.execute(
+                    "SELECT COUNT(*) FROM sqlite_master "
+                    "WHERE type='trigger' AND tbl_name='source_grants'"
+                ).fetchone()[0]
+                == 0
+            )
+
+    asyncio.run(scenario())
+
+
+@pytest.mark.fresh_sdk
+def test_only_hermes_takes_another_user_or_a_custom_root(tmp_path) -> None:
+    async def scenario():
+        home = tmp_path / "home"
+        (home / ".claude" / "projects").mkdir(parents=True)
+        app = application(tmp_path, home=home)
+        async with app.router.lifespan_context(app), client_for(app) as client:
+            for extra in ({"user_id": "wife"}, {"root": str(home / ".claude" / "projects")}):
+                response = await client.post(
+                    "/api/v1/sources/connect",
+                    json={
+                        "source_ids": ["claude-code"],
+                        "request_id": str(uuid4()),
+                        "source_roots": {},
+                        **extra,
+                    },
+                )
+                assert response.status_code == 422, response.text
+                assert response.json()["detail"] == "user_id_requires_multi_user_source"
+            revoke = await client.post(
+                "/api/v1/sources/claude-code/revoke", params={"user_id": "wife"}
+            )
+            assert revoke.status_code == 422
+            # Hermes too: another user must name their own root.
+            rootless = await client.post(
+                "/api/v1/sources/connect",
+                json={
+                    "source_ids": ["hermes"],
+                    "request_id": str(uuid4()),
+                    "source_roots": {},
+                    "user_id": "wife",
+                },
+            )
+            assert rootless.status_code == 422
+            assert rootless.json()["detail"] == "source_root_required_for_user"
+
+    asyncio.run(scenario())
+
+
+def _record(user_id: str, message_id: str, role: str, text: str):
+    return materialize_write_input(
+        EvidenceInput(
+            user_id=user_id,
+            source_id="hermes",
+            conversation_id="session-1",
+            message_id=message_id,
+            role=role,
+            written_by=WrittenBy.PERSON if role == "user" else WrittenBy.AGENT,
+            created_at=datetime(2026, 10, 1, tzinfo=UTC),
+            verbatim=text,
+            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
+        )
+    )
+
+
+def test_assembling_rows_and_batches_are_keyed_by_user(tmp_path) -> None:
+    """Two users' `state.db` share a relative file key and a session id.
+
+    Finishing one user's file must neither take nor drop the other user's
+    staged turns, and the batches it writes hold one user each.
+    """
+    path = tmp_path / "one-memory.sqlite3"
+    queue = DurableWriteQueue(path, sdk_authority=True)
+    file_key = "f" * 64
+    from one_memory.database_access import main_database
+
+    with main_database(path).write(row_factory=sqlite3.Row) as connection, connection:
+        for user in ("local", "wife"):
+            for index, role in enumerate(("user", "assistant")):
+                queue.stage_sdk_input(
+                    _record(user, f"m{index}", role, f"{user} {role}"),
+                    file_key=file_key,
+                    priority="normal",
+                    connection=connection,
+                )
+        queue.finalize_sdk_file(
+            user_id="local", source_id="hermes", file_key=file_key, connection=connection
+        )
+
+    rows = _jobs(path)
+    pending = [row for row in rows if row["state"] == "pending"]
+    assembling = [row for row in rows if row["state"] == "assembling"]
+    assert [
+        {record["user_id"] for record in json.loads(row["payload_json"])["input_records"]}
+        for row in pending
+    ] == [{"local"}]
+    assert [split_lane(row["source_key"]) for row in assembling] == [("wife", "hermes")]
+    assert pending[0]["session_key"] != assembling[0]["session_key"]
+
+
+def _observed(response) -> tuple[int, bytes]:
+    return response.status_code, response.content
+
+
+@pytest.mark.fresh_sdk
+def test_another_users_id_answers_exactly_like_an_id_that_does_not_exist(
+    tmp_path, monkeypatch
+) -> None:
+    """Comparing responses must not tell whether another user's id exists."""
+
+    async def scenario(app, sdk, client):
+        receipts = await _write_both_users(app, sdk, client)
+        [wife_memory] = [
+            memory_id
+            for memory_id, row in sdk.memories.items()
+            if row["user_id"] == "wife" and row["content"] == "wife drinks coffee"
+        ]
+        before = {key: dict(row) for key, row in sdk.memories.items()}
+        with sqlite3.connect(app.state.settings.data_dir / "one-memory.sqlite3") as db:
+            keys = [row[0] for row in db.execute("SELECT idempotency_key FROM memory_write_jobs")]
+        wife_key = next(key for key in keys if key.startswith("user:wife:"))
+
+        pairs = [
+            ("GET", f"/api/v2/memories/{wife_memory}", "/api/v2/memories/no-such-memory", {}),
+            (
+                "PUT",
+                f"/api/v2/memories/{wife_memory}",
+                "/api/v2/memories/no-such-memory",
+                {"json": {"content": "stolen"}},
+            ),
+            ("DELETE", f"/api/v2/memories/{wife_memory}", "/api/v2/memories/no-such-memory", {}),
+            (
+                "GET",
+                f"/api/v2/memories/additions/{receipts['add:wife']}",
+                f"/api/v2/memories/additions/{uuid4()}",
+                {},
+            ),
+            ("GET", f"/api/v2/memory-writes/{wife_key}", "/api/v2/memory-writes/no-such-id", {}),
+        ]
+        for method, theirs, missing, kwargs in pairs:
+            other = await client.request(method, theirs, **kwargs)
+            absent = await client.request(method, missing, **kwargs)
+            assert _observed(other) == _observed(absent), (method, theirs)
+            assert other.status_code == (204 if method == "DELETE" else 404)
+        assert sdk.memories == before
+
+    run_with_sdk(tmp_path, monkeypatch, scenario)

memhub/apps/core/tests/test_policy_api_wiring.py

@@ -173,12 +173,14 @@ def test_first_import_gate_waits_for_every_selected_history_job() -> None:
     jobs = [
         SimpleNamespace(
             operation="history",
+            user_id="local",
             source_id="cursor",
             created_at=datetime(2026, 10, 18, tzinfo=UTC),
             status="completed",
         ),
         SimpleNamespace(
             operation="history",
+            user_id="local",
             source_id="codex",
             created_at=datetime(2026, 10, 18, tzinfo=UTC),
             status="running",

memhub/apps/core/tests/test_read_path_freshness_batch.py

@@ -40,6 +40,7 @@ def library(tmp_path):
             provider_kind=ProviderKind.OLLAMA,
             model="hy-bot-phi4",
             embedding_model="nomic-embed-text",
+            embedding_base_url="http://127.0.0.1:11434",
         ),
         secrets,
     )

memhub/apps/core/tests/test_recall_raw_fallback.py

@@ -210,7 +210,7 @@ def test_recall_route_falls_back_and_keeps_the_raw_grant(tmp_path, monkeypatch):
     async def no_model(_app):
         return False
 
-    async def raw(_app, query, *, limit, sources):
+    async def raw(_app, query, *, limit, sources, user_id="local"):
         searched.append(sources)
         return (_raw("r1", "上周决定用 Postgres", source="cursor"),)
 

memhub/apps/core/tests/test_sdk_client_construction.py

@@ -0,0 +1,61 @@
+"""SDK clients of one home are constructed one at a time.
+
+Build 35, clean install: right after the model was activated, the write
+drain's client and a UI read client started in the same second. Each opened
+Chroma on the same empty vector directory, Chroma's shared System cache has
+no lock around that first open, and neither client reached `VectorStore
+ready`. The first write job was lost as unknown.
+"""
+
+import threading
+import time
+
+from one_memory import hy_sdk_runtime
+from one_memory.hy_sdk_runtime import acquire_client, builtin_retrieval_snapshot
+
+
+def test_two_clients_on_a_fresh_home_are_constructed_one_at_a_time(tmp_path, monkeypatch):
+    real = hy_sdk_runtime.HyMemoryClient
+    state = {"inside": 0, "most": 0}
+    count = threading.Lock()
+
+    def recording_client(**options):
+        with count:
+            state["inside"] += 1
+            state["most"] = max(state["most"], state["inside"])
+        try:
+            # Widen the window two unserialized constructors would share.
+            time.sleep(0.2)
+            return real(**options)
+        finally:
+            with count:
+                state["inside"] -= 1
+
+    monkeypatch.setattr(hy_sdk_runtime, "HyMemoryClient", recording_client)
+    start = threading.Barrier(2)
+    leases: list[hy_sdk_runtime.ClientLease] = []
+    failures: list[BaseException] = []
+
+    def open_client():
+        start.wait()
+        try:
+            leases.append(
+                acquire_client(builtin_retrieval_snapshot(), api_key=None, data_dir=tmp_path)
+            )
+        except BaseException as error:  # noqa: BLE001 - reported below
+            failures.append(error)
+
+    threads = [threading.Thread(target=open_client) for _ in range(2)]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join(120)
+    try:
+        assert failures == []
+        assert len(leases) == 2
+        assert state["most"] == 1
+        for lease in leases:
+            assert lease.client.memory_stats(user_id="local") is not None
+    finally:
+        for lease in leases:
+            lease.close()

memhub/apps/core/tests/test_sdk_data_plane_migration.py

@@ -37,6 +37,7 @@ from one_memory.sdk_migration_runner import (
     abandoned_legacy_work,
     commit_sdk_cutover,
     move_pending_dispatches,
+    prepare_legacy_work_for_cutover,
     prepare_legacy_write_queue_for_cutover,
     recover_abandoned_staging,
     resume_legacy_cleanup,
@@ -707,6 +708,7 @@ def test_cutover_waits_until_the_new_runtime_reads_every_chat_memory(store, acti
         "chat_readable": 1,
         "productivity_expected": 0,
         "productivity_readable": 0,
+        "chat_missing_before_migration": 0,
         "passed": False,
     }
     assert store.authority() is MemoryAuthority.LEGACY
@@ -773,18 +775,186 @@ def test_retired_coding_experiences_do_not_block_but_an_empty_store_does(store,
     assert (result.readback.productivity_expected, result.readback.productivity_readable) == (2, 1)
 
 
-def test_memories_without_a_model_profile_keep_legacy_authority(store, monkeypatch):
+def test_a_home_without_a_model_profile_migrates_on_the_builtin_embedding(store, monkeypatch):
+    """#234: no generation model was ever configured, and the upgrade stopped.
+
+    No profile means no LLM, not no embedding: the vectors are the built-in
+    model's, the same space the Runtime reads with. They are reattached and
+    read back through it, and the client is opened without resolving a key.
+    """
+    from one_memory.hy_sdk_runtime import builtin_retrieval_snapshot, vector_collection_bases
+
     monkeypatch.setattr("one_memory.sdk_migration_runner.read_active_profile", lambda _db: None)
+    home = store.database_path.parent
+    builtin = builtin_retrieval_snapshot()
+    _current, legacy_bases = vector_collection_bases(builtin)
+    client = _chroma(home)
+    _fill(client, f"{legacy_bases[0]}_512", ["m1", "m2"])
+    del client
+    _confirmed(store, "m1", "m2")
+    opened: list[str] = []
+
+    def open_client(profile):
+        opened.append(profile.profile_id)
+        return _reading({"m1", "m2"})(profile)
+
+    result = run_startup_migration(
+        data_dir=home,
+        runtime_build="21",
+        sdk_version="2.0.5",
+        namespace="governed-v2",
+        open_client=open_client,
+    )
+
+    assert result.state == "cutover"
+    assert opened == [builtin.profile_id]
+    assert [item.legacy for item in result.reattached] == [f"{legacy_bases[0]}_512"]
+    assert result.readback is not None and result.readback.passed
+    assert store.authority() is MemoryAuthority.SDK
+
+
+def test_the_builtin_readback_client_resolves_no_secret(tmp_path, monkeypatch):
+    """The built-in snapshot has no stored version and no key to look up."""
+    from one_memory import sdk_migration_verify
+    from one_memory.hy_sdk_runtime import builtin_retrieval_snapshot
+
+    leased: list[tuple[str, object]] = []
+
+    class Lease:
+        client = object()
+
+        def close(self) -> None:
+            leased.append(("closed", None))
+
+    def acquire(profile, *, api_key, data_dir):
+        leased.append((profile.profile_id, api_key))
+        return Lease()
+
+    def no_lookup(*_args, **_kwargs):
+        raise AssertionError("a key-less profile must not touch the secret store")
+
+    monkeypatch.setattr("one_memory.hy_sdk_runtime.acquire_client", acquire)
+    monkeypatch.setattr(
+        "one_memory.model_profiles.ModelProfileStore.resolve_snapshot_secret", no_lookup
+    )
+    with sdk_migration_verify.runtime_sdk_client(
+        tmp_path / "missing.sqlite3", tmp_path, builtin_retrieval_snapshot()
+    ) as client:
+        assert client is Lease.client
+    assert leased == [("builtin-retrieval", None), ("closed", None)]
+
+
+def test_vectors_left_by_a_deleted_profile_stop_the_upgrade_by_name(store, monkeypatch):
+    """No active profile, and the vectors sit in another profile's space.
+
+    The built-in model cannot read them, so the old abort was right for this
+    one shape; it now says what is actually wrong, before anything changes.
+    """
+    from one_memory.hy_sdk_runtime import vector_collection_bases
+    from one_memory.model_profiles import ModelProfileSnapshot, ProviderKind
+
+    monkeypatch.setattr("one_memory.sdk_migration_runner.read_active_profile", lambda _db: None)
+    deleted = ModelProfileSnapshot(
+        profile_id="deleted",
+        revision=3,
+        provider_kind=ProviderKind.OPENAI_COMPATIBLE,
+        base_url="https://models.example/v1",
+        model="chat",
+        embedding_provider_kind=ProviderKind.OPENAI_COMPATIBLE,
+        embedding_base_url="https://models.example/v1",
+        embedding_model="text-embedding-3-large",
+        embedding_dimensions=1024,
+        timeout_seconds=60,
+        max_concurrency=1,
+        context_window=None,
+        has_api_key=True,
+    )
+    current, _legacy = vector_collection_bases(deleted)
+    home = store.database_path.parent
+    client = _chroma(home)
+    _fill(client, f"{current}_1024", ["m1"])
+    del client
     _confirmed(store, "m1")
 
-    with pytest.raises(DataPlaneMigrationError, match="sdk_migration_model_profile_required"):
+    with pytest.raises(DataPlaneMigrationError, match="sdk_migration_vector_profile_missing"):
         run_startup_migration(
-            data_dir=store.database_path.parent,
+            data_dir=home,
             runtime_build="21",
             sdk_version="2.0.5",
             namespace="governed-v2",
+            open_client=_reading({"m1"}),
         )
     assert store.authority() is MemoryAuthority.LEGACY
+    assert not (home / "backups").exists()
+
+
+def test_confirmed_chats_the_sdk_had_already_merged_do_not_fail_the_upgrade(store, active_profile):
+    """#229/#240: 658 confirmed chats, 657 in the store, and the upgrade failed.
+
+    A 1.0.4 library can hold confirmed rows whose SDK node had been merged or
+    deleted before the upgrade; no migration can read those back. The check
+    holds chat to what the store held before this run and counts the rest.
+    """
+    from one_memory.hy_sdk_runtime import vector_collection_bases
+
+    home = store.database_path.parent
+    stored = [f"chat-{index:03d}" for index in range(657)]
+    current, _legacy = vector_collection_bases(active_profile)
+    client = _chroma(home)
+    _fill(client, f"{current}_512", stored)
+    del client
+    _confirmed(store, *stored, "chat-merged-before-upgrade")
+
+    result = run_startup_migration(
+        data_dir=home,
+        runtime_build="21",
+        sdk_version="2.0.5",
+        namespace="governed-v2",
+        open_client=_reading(set(stored)),
+    )
+
+    assert result.state == "cutover"
+    assert result.readback is not None
+    assert result.readback.as_document() == {
+        "chat_expected": 657,
+        "chat_readable": 657,
+        "productivity_expected": 0,
+        "productivity_readable": 0,
+        "chat_missing_before_migration": 1,
+        "passed": True,
+    }
+    assert store.authority() is MemoryAuthority.SDK
+
+
+def test_a_chat_in_the_store_before_the_upgrade_must_still_read_back(store, active_profile):
+    """Only what was already gone is excused; losing a stored memory still fails."""
+    from one_memory.hy_sdk_runtime import vector_collection_bases
+    from one_memory.sdk_migration_verify import MemoryReadbackFailed
+
+    home = store.database_path.parent
+    current, _legacy = vector_collection_bases(active_profile)
+    client = _chroma(home)
+    _fill(client, f"{current}_512", ["m1", "m2"])
+    del client
+    _confirmed(store, "m1", "m2", "merged")
+
+    with pytest.raises(MemoryReadbackFailed) as caught:
+        run_startup_migration(
+            data_dir=home,
+            runtime_build="21",
+            sdk_version="2.0.5",
+            namespace="governed-v2",
+            open_client=_reading({"m1"}),
+        )
+    assert caught.value.report.as_document() == {
+        "chat_expected": 2,
+        "chat_readable": 1,
+        "productivity_expected": 0,
+        "productivity_readable": 0,
+        "chat_missing_before_migration": 1,
+        "passed": False,
+    }
+    assert store.authority() is MemoryAuthority.LEGACY
 
 
 def test_a_build_20_home_gets_its_vectors_back_and_is_checked_against_its_backup(
@@ -896,6 +1066,116 @@ def test_legacy_work_that_may_have_reached_the_sdk_does_not_block_cutover(tmp_pa
     assert store.authority() is MemoryAuthority.SDK
 
 
+def test_pre_upgrade_unknown_writes_are_settled_at_cutover_not_retried(store):
+    """A migrated 1.0.4 home kept 1000+ jobs unknown forever.
+
+    The legacy pipeline invoked them, so the SDK's write-outcome inquiry knows
+    none of them and the automatic reconcile could never settle one.
+    """
+    from one_memory.memory_server.durable_queue import (
+        CANCELLED,
+        PENDING,
+        RUNNING,
+        UNKNOWN,
+    )
+
+    queue = DurableWriteQueue(store.database_path)
+
+    def job(key: str, state: str, *, invoked: bool) -> str:
+        identifier = queue.submit(
+            WriteRequest(
+                internal_session_id="session-1",
+                source_id="cursor",
+                batch_identity=BatchIdentity(
+                    internal_session_id="session-1", first_round=1, last_round=1
+                ),
+                evidence_ids=["gone"],
+                idempotency_key=key,
+            )
+        ).job_id
+        with main_database(store.database_path).write() as database, database:
+            database.execute(
+                "UPDATE memory_write_jobs SET state=?,hy_invoked=?,"
+                "last_error='model_content_outcome_unknown' WHERE job_id=?",
+                (state, int(invoked), identifier),
+            )
+        return identifier
+
+    # Their Evidence is gone too, which must not block the cutover.
+    unknown = [job(f"unknown-{index}", UNKNOWN, invoked=True) for index in range(3)]
+    sent_running = job("sent-running", RUNNING, invoked=True)
+    finished = job("finished", "completed", invoked=True)
+
+    first = prepare_legacy_work_for_cutover(store.database_path)
+    assert first.abandoned == {"unknown_write_jobs": 4}
+    # Resumed after an interruption: nothing changes, the count is the same.
+    again = prepare_legacy_work_for_cutover(store.database_path)
+    assert again.as_document() == first.as_document()
+
+    with main_database(store.database_path).read() as database:
+        rows = dict(
+            (str(row[0]), (str(row[1]), str(row[2]), int(row[3])))
+            for row in database.execute(
+                "SELECT job_id,state,last_error,hy_invoked FROM memory_write_jobs"
+            )
+        )
+    for identifier in (*unknown, sent_running):
+        assert rows[identifier] == (CANCELLED, "abandoned_at_cutover", 1)
+    assert rows[finished][0] == "completed"
+    surviving = DurableWriteQueue(store.database_path, sdk_authority=True)
+    assert surviving.unknown_jobs() == ()
+    # Never requeued: they may already have written.
+    assert surviving.retry_unknown_confirmed(unknown[0]) == 0
+    assert surviving.readmit_parked() == 0
+    assert PENDING not in {state for state, _, _ in rows.values()}
+
+
+def test_retrying_unknown_writes_works_after_the_legacy_tables_are_dropped(store):
+    """The retry button raised `no such table: memory_tasks` after an upgrade."""
+    from one_memory.memory_server.durable_queue import PENDING, UNKNOWN
+    from one_memory.target_schema import drop_legacy_tables
+
+    queue = DurableWriteQueue(store.database_path)
+    identifier = queue.submit(
+        WriteRequest(
+            internal_session_id="session-1",
+            source_id="cursor",
+            batch_identity=BatchIdentity(
+                internal_session_id="session-1", first_round=1, last_round=1
+            ),
+            evidence_ids=["e1"],
+            idempotency_key="after-upgrade",
+        )
+    ).job_id
+    drop_legacy_tables(store.database_path)
+    assert legacy_tables_present(store.database_path) == ()
+    old = datetime(2000, 1, 1, tzinfo=UTC).isoformat()
+
+    def make_unknown(code: str, attempts: int) -> None:
+        with main_database(store.database_path).write() as database, database:
+            database.execute(
+                "UPDATE memory_write_jobs SET state=?,hy_invoked=1,last_error=?,"
+                "attempts=?,updated_at=? WHERE job_id=?",
+                (UNKNOWN, code, attempts, old, identifier),
+            )
+
+    for sdk_authority in (True, False):
+        surviving = DurableWriteQueue(store.database_path, sdk_authority=sdk_authority)
+        make_unknown("model_content_outcome_unknown", 1)
+        assert surviving.resolve_unknown_from_linked_output(identifier) is False
+        assert surviving.retry_unknown_confirmed(identifier) == 1
+        assert surviving.get("after-upgrade").state == PENDING
+
+        make_unknown("hy_memory_timeout", 1)
+        since = datetime.now(UTC)
+        assert surviving.retry_timed_out_unknown_after_reconcile(older_than=since) == 1
+        make_unknown("model_content_outcome_unknown", 1)
+        assert surviving.retry_first_unknown_after_reconcile(older_than=since) == 1
+        if sdk_authority:
+            # The SDK-authority queue never brings a dropped table back.
+            assert legacy_tables_present(store.database_path) == ()
+
+
 def _protective(home: Path) -> Path:
     return home / "hy-memory" / ".governed-v2.pre-migration-0123456789abcdef"
 
@@ -961,7 +1241,13 @@ def test_host_capture_is_fenced_for_the_whole_migration(store):
     )
 
     assert result.state == "cutover"
-    assert fenced == {"bundle": True, "prepare": True, "cutover": True, "cleanup": True}
+    assert fenced == {
+        "bundle": True,
+        "prepare": True,
+        "vectors": True,
+        "cutover": True,
+        "cleanup": True,
+    }
     assert not sdk_migration_capture_fenced(home)
 
 
@@ -1242,7 +1528,7 @@ def test_the_sdk_memory_map_draws_sdk_memories_without_legacy_tables(tmp_path) -
             original = app.state.sdk_client_handle
             app.state.sdk_client_handle = Handle()
 
-            async def graph_snapshot(*, limit):
+            async def graph_snapshot(*, limit, user_id="local"):
                 del limit
                 return HyGraphSnapshot(
                     nodes=(HyGraphNode(node_id="t1", content="topic", layer="TOPIC"),),
@@ -1264,6 +1550,8 @@ def test_the_sdk_memory_map_draws_sdk_memories_without_legacy_tables(tmp_path) -
 
     graph = asyncio.run(scenario())
     assert listed[0]["include_sources"] == ["cursor"]
+    assert listed[0]["scene"] == "all"
+    assert listed[0]["statuses"] == ["active"]
     assert (listed[0]["offset"], listed[0]["limit"]) == (100, 100)
     assert (graph["total_memories"], graph["projected_memories"]) == (7, 4)
     assert {node["node_id"] for node in graph["nodes"]} == {
@@ -1288,6 +1576,71 @@ def test_the_sdk_memory_map_draws_sdk_memories_without_legacy_tables(tmp_path) -
     assert graph["hy_graph_available"] is True
 
 
+@pytest.mark.integration
+@pytest.mark.fresh_sdk
+def test_sdk_memory_map_still_draws_memories_from_a_revoked_source(tmp_path) -> None:
+    # Revoking a source stops new reads from it; memories already distilled
+    # from it stay visible, so the map agrees with the list.
+    async def scenario():
+        app = create_app(_app_settings(tmp_path), secret_store=InMemorySecretStore())
+
+        class Client:
+            def list_memories(self, **_kwargs):
+                return {
+                    "vdb": {
+                        "memories": [
+                            {
+                                "memory_id": "kept",
+                                "content": "distilled before revocation",
+                                "layer": "l2_fact",
+                                "status": "active",
+                                "user_id": "local",
+                                "agent_id": "all-apps",
+                                "session_id": "s1",
+                                "source": "cursor",
+                            }
+                        ],
+                        "total": 1,
+                    }
+                }
+
+        class Handle:
+            async def client(self):
+                return Client()
+
+            async def close(self):
+                return None
+
+        async with (
+            app.router.lifespan_context(app),
+            AsyncClient(
+                transport=ASGITransport(app=app),
+                base_url="http://test",
+                headers={"Authorization": "Bearer authority-test"},
+            ) as client,
+        ):
+            app.state.sdk_client_handle = Handle()
+            database = app.state.settings.data_dir / "one-memory.sqlite3"
+            with sqlite3.connect(database) as db:
+                db.execute(
+                    "INSERT INTO source_grants "
+                    "(user_id,source_id,root_path,requested_path,root_identity,"
+                    "candidate_kind,granted_at,revoked_at,revision) VALUES "
+                    "('local','cursor','/fixture','/fixture','fixture','default',"
+                    "'2026-10-01T00:00:00Z','2026-10-02T00:00:00Z',1)"
+                )
+            response = await client.get(
+                "/api/v2/memories/graph",
+                params={"source": "cursor", "limit": 100},
+            )
+            assert response.status_code == 200
+            return response.json()
+
+    graph = asyncio.run(scenario())
+    assert (graph["total_memories"], graph["projected_memories"]) == (1, 1)
+    assert "memory:kept" in {node["node_id"] for node in graph["nodes"]}
+
+
 def test_a_completed_sdk_write_does_not_touch_retired_evidence(store) -> None:
     """Build 21 logged RetiredAuthorityAccess after every successful write."""
     from types import SimpleNamespace

memhub/apps/core/tests/test_sdk_migration_bundle.py

@@ -91,7 +91,7 @@ def test_bundle_contains_management_sdk_config_and_verified_manifest(tmp_path):
     assert manifest["bundle_id"] == "migration-1"
     assert manifest["sdk_namespace"] == "governed-v2"
     assert manifest["runtime_build"] == "build-13"
-    assert manifest["snapshot_sdk_version"] == "2.0.7"
+    assert manifest["snapshot_sdk_version"] == "2.0.9"
     paths = {item["path"]: item for item in manifest["files"]}
     assert {
         "management/one-memory.sqlite3",

memhub/apps/core/tests/test_sdk_migration_log.py

@@ -306,7 +306,7 @@ def test_the_runner_names_the_step_and_sub_step_that_failed(tmp_path, monkeypatc
         ("step.finished", "preflight.profile_read"),
         ("step.finished", "preflight.resumable_identity"),
         ("step.finished", "preflight.legacy_ids_scan"),
-        ("step.finished", "preflight.model_profile_check"),
+        ("step.finished", "preflight.vector_space_check"),
         ("step.finished", "prepare.recover_abandoned_staging"),
         ("step.finished", "bundle.ensure"),
         ("step.finished", "bundle.restore_point"),

memhub/apps/core/tests/test_sdk_migration_restore.py

@@ -463,11 +463,17 @@ def test_a_run_killed_after_its_restore_point_is_rolled_back_on_the_next_start(h
 
 
 def test_a_preflight_failure_changes_nothing_and_needs_no_restore(home, monkeypatch):
+    def unreadable(_data_dir, _profile):
+        raise DataPlaneMigrationError("sdk_migration_vector_profile_missing")
+
     monkeypatch.setattr("one_memory.sdk_migration_runner.read_active_profile", lambda _db: None)
+    monkeypatch.setattr(
+        "one_memory.sdk_migration_runner.vectors_belong_to_another_space", unreadable
+    )
     before = _state(home)
     report: dict[str, object] = {}
 
-    with pytest.raises(DataPlaneMigrationError, match="sdk_migration_model_profile_required"):
+    with pytest.raises(DataPlaneMigrationError, match="sdk_migration_vector_profile_missing"):
         _run(home, report=report)
 
     assert report == {}

memhub/apps/core/tests/test_search_without_profile.py

@@ -1,5 +1,6 @@
 """Model-free SDK search remains available without an active write profile."""
 
+import asyncio
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -95,3 +96,158 @@ async def test_search_without_profile_uses_public_sdk_search() -> None:
     assert options["user_ids"] == ["local"]
     assert options["agent_ids"] == []
     assert options["scene"] == "normal"
+
+
+def _activate(profiles, secrets, *, dimensions: int, model: str = "chat"):
+    from pydantic import SecretStr
+
+    from one_memory.model_profiles import ModelCapabilities, ModelProfileInput
+
+    profile = profiles.create(
+        ModelProfileInput(
+            name=f"embedding-{dimensions}",
+            provider_kind=ProviderKind.OPENAI_COMPATIBLE,
+            base_url="https://models.example/v1",
+            model=model,
+            embedding_provider_kind=ProviderKind.OPENAI_COMPATIBLE,
+            embedding_base_url="https://models.example/v1",
+            embedding_model="qwen3-embedding-4b",
+            embedding_dimensions=dimensions,
+            api_key=SecretStr("sk-test"),
+        ),
+        secrets,
+    )
+    profiles.record_capabilities(
+        profile.profile_id,
+        expected_revision=profile.revision,
+        capabilities=ModelCapabilities(
+            endpoint_reachable=True,
+            model_available=True,
+            structured_output=True,
+            embedding_available=True,
+        ),
+        secrets=secrets,
+    )
+    profiles.activate(profile.profile_id, secrets)
+    return profiles.snapshot(profile.profile_id, profiles.active_identity()[1])
+
+
+class _Recorder:
+    """Stands in for `acquire_client`: records the collection each client opens."""
+
+    def __init__(self, data_dir: Path) -> None:
+        self.data_dir = data_dir
+        self.opened: list[tuple[str, int | None, str | None]] = []
+        self.closed: list[str] = []
+
+    def __call__(self, profile, *, api_key, data_dir, http_transport_factory=None):
+        from one_memory.hy_sdk_runtime import build_sdk_config
+
+        config = build_sdk_config(profile, api_key=api_key, data_dir=data_dir)
+        name = config.vector_store.collection_name
+        self.opened.append((name, config.vector_store.embedding_dims, api_key))
+        return SimpleNamespace(
+            client=SimpleNamespace(collection=name),
+            close=lambda: self.closed.append(name),
+        )
+
+
+@pytest.mark.anyio
+async def test_reads_open_the_collection_the_active_profile_writes(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """#242: a 2560-dim profile wrote `memhub_<sha>_2560`, reads opened `_512`."""
+    from one_memory.hy_sdk_runtime import build_sdk_config
+    from one_memory.model_profiles import ModelProfileStore
+    from one_memory.sdk_read_handle import ActiveProfileReadHandle
+    from one_memory.secrets import InMemorySecretStore
+
+    recorder = _Recorder(tmp_path)
+    monkeypatch.setattr("one_memory.hy_sdk_runtime.acquire_client", recorder)
+    profiles = ModelProfileStore(tmp_path / "one-memory.sqlite3")
+    secrets = InMemorySecretStore()
+    handle = ActiveProfileReadHandle(profiles=profiles, secrets=secrets, data_dir=tmp_path)
+
+    builtin = build_sdk_config(builtin_retrieval_snapshot(), api_key=None, data_dir=tmp_path)
+    assert (await handle.client()).collection == builtin.vector_store.collection_name
+
+    written = _activate(profiles, secrets, dimensions=2560)
+    writes = build_sdk_config(written, api_key="sk-test", data_dir=tmp_path)
+
+    async def read() -> str:
+        return str((await handle.client()).collection)
+
+    assert await asyncio.create_task(read()) == writes.vector_store.collection_name
+    assert recorder.opened[-1] == (writes.vector_store.collection_name, 2560, "sk-test")
+    assert writes.vector_store.collection_name != builtin.vector_store.collection_name
+    await handle.close()
+
+
+@pytest.mark.anyio
+async def test_a_profile_change_rebuilds_reads_without_closing_one_in_flight(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    from one_memory.model_profiles import ModelProfileStore
+    from one_memory.sdk_read_handle import ActiveProfileReadHandle
+    from one_memory.secrets import InMemorySecretStore
+
+    recorder = _Recorder(tmp_path)
+    monkeypatch.setattr("one_memory.hy_sdk_runtime.acquire_client", recorder)
+    profiles = ModelProfileStore(tmp_path / "one-memory.sqlite3")
+    secrets = InMemorySecretStore()
+    handle = ActiveProfileReadHandle(profiles=profiles, secrets=secrets, data_dir=tmp_path)
+    _activate(profiles, secrets, dimensions=1024)
+
+    holding = asyncio.Event()
+    finish = asyncio.Event()
+
+    async def slow_read() -> str:
+        client = await handle.client()
+        holding.set()
+        await finish.wait()
+        return str(client.collection)
+
+    in_flight = asyncio.create_task(slow_read())
+    await holding.wait()
+    [(old, _, _)] = recorder.opened
+
+    _activate(profiles, secrets, dimensions=2560, model="chat-2")
+
+    async def read() -> str:
+        return str((await handle.client()).collection)
+
+    new = await asyncio.create_task(read())
+    assert new != old
+    # The read that started on the old space still has its client.
+    assert recorder.closed == []
+
+    finish.set()
+    assert await in_flight == old
+    for _ in range(5):
+        await asyncio.sleep(0)
+    assert recorder.closed == [old]
+    await handle.close()
+    assert recorder.closed == [old, new]
+
+
+def test_every_api_read_shares_the_active_profile_handle(tmp_path: Path) -> None:
+    """Library, search, recall, graph, profile, raw, ask and context all read
+    through `_sdk_client_handle`, so it must be the active-profile handle."""
+    from one_memory.api import _sdk_client_handle
+    from one_memory.config import Settings
+    from one_memory.model_profiles import ModelProfileStore
+    from one_memory.sdk_read_handle import ActiveProfileReadHandle
+    from one_memory.secrets import InMemorySecretStore
+
+    state = SimpleNamespace(
+        sdk_client_handle=None,
+        model_profile_store=ModelProfileStore(tmp_path / "one-memory.sqlite3"),
+        secret_store=InMemorySecretStore(),
+        settings=Settings(_env_file=None, data_dir=tmp_path),
+    )
+    app = SimpleNamespace(state=state)
+
+    handle = _sdk_client_handle(app)  # type: ignore[arg-type]
+
+    assert isinstance(handle, ActiveProfileReadHandle)
+    assert _sdk_client_handle(app) is handle is state.sdk_client_handle  # type: ignore[arg-type]

memhub/apps/core/tests/test_v2_authority_and_call_events.py

@@ -57,10 +57,10 @@ def client_for(app, headers=None):
 
 
 class Answerer:
-    async def answer(self, question):
+    async def answer(self, question, *, user_id="local"):
         return SdkMemoryAnswer(answer="真实数据。", memories=(MEMORY,), mode="extractive")
 
-    async def answer_stream(self, question):
+    async def answer_stream(self, question, *, user_id="local"):
         yield {"type": "recall", "memories": (MEMORY,)}
         yield {
             "type": "final",

memhub/apps/core/uv.lock

@@ -991,7 +991,7 @@ wheels = [
 
 [[package]]
 name = "hy-memory"
-version = "2.0.7"
+version = "2.0.9"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "chromadb" },
@@ -1008,9 +1008,9 @@ dependencies = [
     { name = "scikit-learn" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/17/b5/87a43c8d8b77fdfbbe7974d1e93af50ddf82317c5d56e180b865fb19e181/hy_memory-2.0.7.tar.gz", hash = "sha256:85636487e5bd4b6595a8c15301499efb365b6010c236a45c51c144f6986a4222", size = 854913, upload-time = "2026-10-28T03:35:38.127Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/48/28/e01fd9a92cd090c8236df0dd06dae049c5de66345e5bd9653497ed56125e/hy_memory-2.0.9.tar.gz", hash = "sha256:5f55ea92044ced19a00b4e56c565215adedd3439a1bdb9cfe9ffe42387c8f1a1", size = 858323, upload-time = "2026-11-01T00:29:49.914Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/b8/a6e0bfd17aeb432b0470f4dc707271e6476f5ac34f3b301ab3ad2e1c0d83/hy_memory-2.0.7-py3-none-any.whl", hash = "sha256:80a501e17987202ee1150a91b071313e890300620f353f9e89c967286dc1a645", size = 919841, upload-time = "2026-10-28T03:35:35.399Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/44/4368555a408a58daf902c81b62184a3c99f12abd45d4f1144bf79f171a6f/hy_memory-2.0.9-py3-none-any.whl", hash = "sha256:95dbea232d2041f9b0ea3d08dd751603c2a5c0e4422b97e74f664e6ca913549e", size = 923250, upload-time = "2026-11-01T00:29:47.814Z" },
 ]
 
 [[package]]
@@ -1837,7 +1837,7 @@ requires-dist = [
     { name = "fastapi", specifier = ">=0.141.1" },
     { name = "filelock", specifier = ">=3.32.4" },
     { name = "httpx", specifier = ">=0.28.1" },
-    { name = "hy-memory", specifier = "==2.0.7" },
+    { name = "hy-memory", specifier = "==2.0.9" },
     { name = "keyring", specifier = ">=25.7.0" },
     { name = "numpy", specifier = "==2.5.2" },
     { name = "onnxruntime", specifier = "==1.23.2" },

memhub/apps/desktop/src/diagnostics-ipc.test.ts

@@ -230,39 +230,21 @@ it("filters raw Core INFO and DEBUG while preserving warnings and errors", async
   ).toBe(true);
 });
 
-it("shows HY pipeline metrics without exposing model content", async () => {
-  const dataDir = await mkdtemp(
-    path.join(os.tmpdir(), "om-debug-hy-pipeline-"),
-  );
+it("does not read HY's own log directory", async () => {
+  // MemHub turns the HY pipeline log off; files left by older builds and
+  // HY's text log stay on disk but are not part of the Debug panel.
+  const dataDir = await mkdtemp(path.join(os.tmpdir(), "om-debug-hy-logs-"));
   roots.push(dataDir);
-  const pipelineDir = path.join(
-    dataDir,
-    "hy-memory",
-    "governed-v2",
-    "logs",
-    "default",
-  );
-  await mkdir(pipelineDir, { recursive: true });
-  const target = path.join(pipelineDir, "2026-10-14.log");
-  await writeFile(target, "");
+  const hyLogs = path.join(dataDir, "hy-memory", "governed-v2", "logs");
+  await mkdir(path.join(hyLogs, "default"), { recursive: true });
   const cursor = await captureDebugLogCursor(dataDir);
-  const pipelineEntry = {
-    request_id: "request-safe-1",
-    user_id: "private-user",
-    agent_id: "private-agent",
-    session_id: "private-session",
-    step: "EXTRACT",
-    prompt: "private prompt",
-    content: "private response",
-    parsed: "private parsed output",
-    tokens: 42,
-    elapsed_ms: 123.5,
-    timestamp: "2026-10-14T10:01:00.000",
-  };
-  await appendFile(target, `${JSON.stringify(pipelineEntry)}\n`);
   await writeFile(
-    path.join(dataDir, "hy-memory", "governed-v2", "logs", "hy_memory.log"),
-    `${JSON.stringify({ ...pipelineEntry, request_id: "must-not-appear" })}\n`,
+    path.join(hyLogs, "default", "2026-10-14.log"),
+    `${JSON.stringify({ request_id: "old-pipeline", step: "EXTRACT" })}\n`,
+  );
+  await writeFile(
+    path.join(hyLogs, "hy_memory.log"),
+    "2026-10-14 10:01:00 [WARNING] [-] hy_memory.client: hy text log\n",
   );
 
   const snapshot = await readDebugLogSnapshot(
@@ -271,29 +253,11 @@ it("shows HY pipeline metrics without exposing model content", async () => {
     cursor,
   );
 
-  expect(snapshot.entries).toEqual([
-    expect.objectContaining({
-      service: "hy-memory",
-      component: "hy.pipeline",
-      event: "hy.pipeline.extract",
-      message: "EXTRACT · 42 tokens · 124 ms",
-      duration_ms: 123.5,
-      trace_id: "request-safe-1",
-      details: { phase: "EXTRACT", count: 42 },
-      source: "pipeline",
-    }),
-  ]);
-  const serialized = JSON.stringify(snapshot);
-  for (const secret of [
-    "private prompt",
-    "private response",
-    "private parsed output",
-    "private-user",
-    "private-agent",
-    "private-session",
-  ]) {
-    expect(serialized).not.toContain(secret);
-  }
+  expect(snapshot.entries).toEqual([]);
+  expect(cursor).toEqual({
+    diagnosticLogs: [],
+    serviceLogs: expect.any(Array),
+  });
 });
 
 it("logs a renderer ui-action with action, page, phase and the shared trace id", async () => {

memhub/apps/desktop/src/diagnostics-ipc.ts

@@ -18,7 +18,6 @@ const UI_TRACE = "one-memory:log-ui-trace";
 const DEBUG_LOGS = "one-memory:get-debug-logs";
 const DEBUG_LOG_NAME =
   /^diagnostic-(runtime|core|host-bridge|desktop|cli)\.jsonl(?:\.\d+)?$/;
-const PIPELINE_LOG_NAME = /^\d{4}-\d{2}-\d{2}\.log$/;
 const SERVICE_LOG_NAMES = [
   "service.log",
   "service-error.log",
@@ -30,24 +29,16 @@ interface ServiceLogCursor {
   files: Array<{ device: number; inode: number; offset: number }>;
 }
 
-interface PipelineLogCursor {
-  relativePath: string;
-  device: number;
-  inode: number;
-  offset: number;
-}
-
 export interface DebugLogCursor {
   diagnosticLogs: Array<{ device: number; inode: number; offset: number }>;
   serviceLogs: ServiceLogCursor[];
-  pipelineLogs: PipelineLogCursor[];
 }
 
 export interface DebugLogEntry {
   id: string;
   timestamp: string;
   level: "debug" | "info" | "warn" | "error";
-  service: "runtime" | "core" | "host-bridge" | "desktop" | "cli" | "hy-memory";
+  service: "runtime" | "core" | "host-bridge" | "desktop" | "cli";
   component: string;
   event: string;
   outcome: string;
@@ -57,7 +48,7 @@ export interface DebugLogEntry {
   trace_id?: string;
   details?: Record<string, string | number | boolean | null>;
   message?: string;
-  source: "diagnostic" | "stdout" | "stderr" | "pipeline";
+  source: "diagnostic" | "stdout" | "stderr";
 }
 
 export interface DebugLogSnapshot {
@@ -259,7 +250,6 @@ export async function readDebugLogSnapshot(
   cursor: DebugLogCursor = {
     diagnosticLogs: [],
     serviceLogs: [],
-    pipelineLogs: [],
   },
 ): Promise<DebugLogSnapshot> {
   const started = Number.isFinite(startedAt) ? startedAt : Date.now();
@@ -300,7 +290,6 @@ export async function readDebugLogSnapshot(
       );
     }
   }
-  entries.push(...(await readPipelineLogEntries(dataDir, cursor, started)));
   entries.sort((left, right) =>
     left.timestamp === right.timestamp
       ? left.id.localeCompare(right.id)
@@ -319,7 +308,6 @@ export async function captureDebugLogCursor(
 ): Promise<DebugLogCursor> {
   const directory = path.join(dataDir, "logs");
   const names = await readdir(directory).catch(() => []);
-  const pipelineRoot = path.join(dataDir, "hy-memory", "governed-v2", "logs");
   return {
     diagnosticLogs: (
       await Promise.all(
@@ -355,7 +343,6 @@ export async function captureDebugLogCursor(
         };
       }),
     ),
-    pipelineLogs: await pipelineLogFiles(pipelineRoot),
   };
 }
 
@@ -462,8 +449,8 @@ async function readServiceLogEntries(
       if (!message) continue;
       const level = serviceLogLevel(message, cursor.name);
       // Raw stdout is an implementation trace, not a product event. Core's
-      // structured diagnostics and HY pipeline logs already carry meaningful
-      // successful work with request/task identity. Showing raw INFO/DEBUG
+      // structured diagnostics already carry meaningful successful work with
+      // request/task identity. Showing raw INFO/DEBUG
       // here duplicated those events and turned polling access logs, file
       // watchers and library initialization into thousands of fake "useful"
       // rows. Keep raw output only when it needs attention.
@@ -543,135 +530,6 @@ function logLineTimestamp(
   return new Date(Math.max(startedAt, fallback)).toISOString();
 }
 
-async function pipelineLogFiles(root: string): Promise<PipelineLogCursor[]> {
-  const rootInfo = await lstat(root).catch(() => null);
-  if (!rootInfo?.isDirectory() || rootInfo.isSymbolicLink()) return [];
-  const files: PipelineLogCursor[] = [];
-  const visit = async (directory: string): Promise<void> => {
-    for (const entry of await readdir(directory, { withFileTypes: true })) {
-      const target = path.join(directory, entry.name);
-      if (entry.isSymbolicLink()) continue;
-      if (entry.isDirectory()) {
-        await visit(target);
-        continue;
-      }
-      // The same root also contains HY's human-readable hy_memory.log.
-      // Pipeline files are date-named JSONL; accepting every .log file makes
-      // the Debug poller repeatedly parse unrelated text and still display no
-      // HY entries.
-      if (!entry.isFile() || !PIPELINE_LOG_NAME.test(entry.name)) continue;
-      const info = await safeRegularFile(target);
-      if (!info) continue;
-      files.push({
-        relativePath: path.relative(root, target),
-        device: info.dev,
-        inode: info.ino,
-        offset: info.size,
-      });
-    }
-  };
-  await visit(root);
-  return files;
-}
-
-async function readPipelineLogEntries(
-  dataDir: string,
-  cursor: DebugLogCursor,
-  startedAt: number,
-): Promise<DebugLogEntry[]> {
-  const root = path.join(dataDir, "hy-memory", "governed-v2", "logs");
-  const current = await pipelineLogFiles(root);
-  const baseline = new Map(
-    cursor.pipelineLogs.map((file) => [
-      `${file.device}:${file.inode}`,
-      file.offset,
-    ]),
-  );
-  const entries: DebugLogEntry[] = [];
-  for (const file of current) {
-    const target = path.join(root, file.relativePath);
-    const offset = baseline.get(`${file.device}:${file.inode}`) ?? 0;
-    const info = await safeRegularFile(target);
-    if (!info || info.size <= offset) continue;
-    const content = await readFileFromOffset(target, offset).catch(() => "");
-    let lineNumber = 0;
-    for (const line of content.split("\n")) {
-      lineNumber += 1;
-      if (!line.trim()) continue;
-      const entry = pipelineLogEntry(
-        line,
-        file,
-        lineNumber,
-        offset,
-        startedAt,
-        info.mtimeMs,
-      );
-      if (entry) entries.push(entry);
-    }
-  }
-  return entries;
-}
-
-function pipelineLogEntry(
-  line: string,
-  file: PipelineLogCursor,
-  lineNumber: number,
-  offset: number,
-  startedAt: number,
-  fallbackTime: number,
-): DebugLogEntry | null {
-  let value: Record<string, unknown>;
-  try {
-    value = JSON.parse(line) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-  const step = typeof value.step === "string" ? value.step.trim() : "";
-  if (!step || !/^[A-Za-z0-9_-]{1,80}$/.test(step)) return null;
-  const rawTimestamp =
-    typeof value.timestamp === "string" ? value.timestamp : "";
-  const parsedTimestamp = Date.parse(rawTimestamp);
-  const timestamp = new Date(
-    Math.max(
-      startedAt,
-      Number.isFinite(parsedTimestamp) ? parsedTimestamp : fallbackTime,
-    ),
-  ).toISOString();
-  const elapsed = safeFiniteNumber(value.elapsed_ms);
-  const tokens = safeFiniteNumber(value.tokens);
-  const requestId =
-    typeof value.request_id === "string" && value.request_id.length <= 256
-      ? value.request_id
-      : undefined;
-  return {
-    id: `hy-pipeline:${file.device}:${file.inode}:${offset}:${lineNumber}`,
-    timestamp,
-    level: "info",
-    service: "hy-memory",
-    component: "hy.pipeline",
-    event: `hy.pipeline.${step.toLowerCase().replaceAll("_", "-")}`,
-    outcome: "observed",
-    ...(elapsed === undefined ? {} : { duration_ms: elapsed }),
-    ...(requestId ? { trace_id: requestId } : {}),
-    details: {
-      phase: step,
-      ...(tokens === undefined ? {} : { count: tokens }),
-    },
-    message: [
-      step,
-      ...(tokens === undefined ? [] : [`${Math.round(tokens)} tokens`]),
-      ...(elapsed === undefined ? [] : [`${Math.round(elapsed)} ms`]),
-    ].join(" · "),
-    source: "pipeline",
-  };
-}
-
-function safeFiniteNumber(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value)
-    ? value
-    : undefined;
-}
-
 export function installDiagnosticsIpc(
   options: DiagnosticIpcOptions,
 ): () => void {

memhub/apps/desktop/src/stable-runtime.ts

@@ -133,6 +133,7 @@ const SAFE_STABLE_RUNTIME_ERROR_CODES = new Set([
   "sdk_migration_preflight_failed",
   "sdk_migration_memory_unreadable",
   "sdk_migration_model_profile_required",
+  "sdk_migration_vector_profile_missing",
   "sdk_migration_model_secret_unavailable",
   "sdk_migration_secure_storage_unavailable",
   "sdk_migration_disk_space_insufficient",
@@ -219,6 +220,8 @@ export const STABLE_RUNTIME_USER_MESSAGES: Record<string, string> = {
     "升级前核对发现，新版本还读不到你的全部记忆，所以没有切换数据源，旧数据保持原样可用。请把这个提示反馈给我们；原有记忆数据不会丢失。",
   sdk_migration_model_profile_required:
     "升级记忆数据格式需要先有可用的模型配置，用来核对新版本能否读回你的记忆。请在旧版本中完成模型配置后重启；你的记忆数据不会受到影响。",
+  sdk_migration_vector_profile_missing:
+    "你的记忆是用一个已删除的模型配置生成向量的，当前没有可用的模型配置能读回它们，所以没有升级。请在旧版本中重新添加那个模型配置并启用后重启；你的记忆数据不会受到影响。",
   sdk_migration_model_secret_unavailable:
     "模型密钥读不到（可能被系统钥匙串拒绝），无法核对新版本能否读回你的记忆。请允许 MemHub 访问钥匙串后重新启动；你的记忆数据不会受到影响。",
   sdk_migration_secure_storage_unavailable:

memhub/apps/web/src/ApplicationsHome.test.tsx

@@ -172,7 +172,7 @@ it.each([
     expect(sedimentation).toHaveBeenCalledOnce();
   },
 );
-it("localizes failure and empty states without leaking errors", async () => {
+it("localizes startup recovery and empty states without leaking errors", async () => {
   summary.mockRejectedValue(new Error("synthetic_private_error"));
   Object.assign(window.oneMemory ?? {}, {
     getLanguagePreference: vi
@@ -191,12 +191,15 @@ it("localizes failure and empty states without leaking errors", async () => {
     </LanguageProvider>,
   );
   expect(
-    await screen.findByText("No se puede leer el estado de las memorias"),
+    await screen.findByText(
+      "El servicio se está iniciando; se actualizará automáticamente",
+    ),
   ).toBeTruthy();
+  expect(screen.getByText("0")).toBeTruthy();
   expect(screen.getByText("Aún no hay aplicaciones para mostrar")).toBeTruthy();
   expect(
-    screen.getByRole("button", { name: "Reintentar lectura" }),
-  ).toBeTruthy();
+    screen.queryByRole("button", { name: "Reintentar lectura" }),
+  ).toBeNull();
   expect(document.body.textContent).not.toContain("synthetic_private_error");
 });
 it("shows latest recorded call separately without exposing recent-update detail entries", async () => {
@@ -765,7 +768,7 @@ it("keeps authoritative home and processing data when only the source snapshot b
   expect(screen.getAllByText("整理中")).toHaveLength(2);
   expect(screen.queryByText("状态待核对")).toBeNull();
 });
-it("does not turn a failed home summary into zero or expose a private error", async () => {
+it("keeps a neutral zero while the first home summary read recovers", async () => {
   summary.mockRejectedValue(new Error("private offline detail"));
   render(
     <ApplicationsHome
@@ -775,10 +778,117 @@ it("does not turn a failed home summary into zero or expose a private error", as
       onSettings={() => {}}
     />,
   );
-  await waitFor(() => expect(screen.getByText("暂无法读取")).toBeTruthy());
-  expect(screen.queryByText("0")).toBeNull();
+  await waitFor(() =>
+    expect(screen.getByText("后台正在启动，稍后自动更新")).toBeTruthy(),
+  );
+  expect(screen.getByText("0")).toBeTruthy();
+  expect(screen.getByText("正在准备记忆概览")).toBeTruthy();
+  expect(screen.queryByText(/暂时?无法读取|读取失败/)).toBeNull();
   expect(document.body.textContent).not.toContain("private offline detail");
 });
+it("offers a calm retry after repeated home summary failures", async () => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+  try {
+    summary.mockRejectedValue(new Error("private offline detail"));
+    render(
+      <ApplicationsHome
+        imports={imports}
+        onManage={() => {}}
+        onMemories={() => {}}
+        onSettings={() => {}}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByText("后台正在启动，稍后自动更新")).toBeTruthy(),
+    );
+    await act(async () => vi.advanceTimersByTimeAsync(10_000));
+    expect(await screen.findByText("记忆概览还没准备好")).toBeTruthy();
+    expect(
+      screen.getByText("后台恢复后会自动更新，也可以重新读取。"),
+    ).toBeTruthy();
+    expect(screen.getByRole("button", { name: "重新读取" })).toBeTruthy();
+  } finally {
+    vi.useRealTimers();
+  }
+});
+it("counts repeated stale summaries and recovers on the next confirmed read", async () => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+  try {
+    const stale = {
+      memory_count: 0,
+      latest: null,
+      observed_at: "2026-09-19T00:00:00Z",
+      stale: true,
+    };
+    summary
+      .mockResolvedValueOnce(stale)
+      .mockResolvedValueOnce(stale)
+      .mockResolvedValue({
+        memory_count: 4,
+        latest: null,
+        observed_at: "2026-09-19T00:01:00Z",
+      });
+    render(
+      <ApplicationsHome
+        imports={imports}
+        onManage={() => {}}
+        onMemories={() => {}}
+        onSettings={() => {}}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByText("后台正在启动，稍后自动更新")).toBeTruthy(),
+    );
+    await act(async () => vi.advanceTimersByTimeAsync(10_000));
+    expect(await screen.findByText("记忆概览还没准备好")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "重新读取" }));
+    expect(await screen.findByText("4")).toBeTruthy();
+    expect(screen.queryByText("记忆概览还没准备好")).toBeNull();
+  } finally {
+    vi.useRealTimers();
+  }
+});
+it("labels a retained count as previous data after repeated stale reads", async () => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+  try {
+    const stale = {
+      memory_count: 0,
+      latest: null,
+      observed_at: "2026-09-19T00:00:00Z",
+      stale: true,
+    };
+    summary
+      .mockResolvedValueOnce({
+        memory_count: 601,
+        latest: null,
+        observed_at: "2026-09-19T00:00:00Z",
+      })
+      .mockResolvedValueOnce(stale)
+      .mockResolvedValueOnce(stale)
+      .mockResolvedValue({
+        memory_count: 4,
+        latest: null,
+        observed_at: "2026-09-19T00:01:00Z",
+      });
+    render(
+      <ApplicationsHome
+        imports={imports}
+        onManage={() => {}}
+        onMemories={() => {}}
+        onSettings={() => {}}
+      />,
+    );
+    expect(await screen.findByText("601")).toBeTruthy();
+    await act(async () => vi.advanceTimersByTimeAsync(20_000));
+    expect(screen.getByText("601")).toBeTruthy();
+    expect(screen.getByText("正在显示上次数据，稍后自动更新")).toBeTruthy();
+    await act(async () => vi.advanceTimersByTimeAsync(10_000));
+    expect(await screen.findByText("4")).toBeTruthy();
+    expect(screen.queryByText("正在显示上次数据，稍后自动更新")).toBeNull();
+  } finally {
+    vi.useRealTimers();
+  }
+});
 it("never calls a recall event a success when only stored memories are available", async () => {
   render(
     <ApplicationsHome
@@ -1200,7 +1310,7 @@ it("keeps the conversation-sync checking copy before the first home read", () =>
   expect(screen.queryByText(/个应用已开启/)).toBeNull();
 });
 
-it("does not claim there are no memories while the first summary read is pending", async () => {
+it("shows a provisional zero while the first summary read is pending", async () => {
   summary.mockImplementation(() => new Promise(() => {}));
   history.mockResolvedValue({
     available: true,
@@ -1216,7 +1326,9 @@ it("does not claim there are no memories while the first summary read is pending
       onSettings={() => {}}
     />,
   );
-  await screen.findByText("正在读取动态");
+  await screen.findByText("正在准备记忆概览");
+  expect(screen.getByText("0")).toBeTruthy();
+  expect(screen.getByText("正在核对本机记忆…")).toBeTruthy();
   expect(screen.queryByText("还没有已生成的记忆")).toBeNull();
 });
 

memhub/apps/web/src/ApplicationsHome.tsx

@@ -195,7 +195,7 @@ export function ApplicationsHome({
     null,
   );
   const [syncHealth, setSyncHealth] = useState<LiveSyncHealth[]>([]);
-  const [failed, setFailed] = useState(false);
+  const [summaryFailures, setSummaryFailures] = useState(0);
   const [recentCall, setRecentCall] = useState<CallEvent | null>(null);
   const [callEvents, setCallEvents] = useState<CallEvent[]>([]);
   const [callState, setCallState] = useState<
@@ -554,13 +554,17 @@ export function ApplicationsHome({
       busy = false;
       if (stopped) return;
       if (home.status === "fulfilled") {
-        setFailed(false);
         // stale=true 表示这轮读取超时，数字不代表现状：保留上一次的概览，
-        // 等 10 秒后的下一轮轮询补上，绝不清零也不报错。
-        if (!("stale" in home.value) || !home.value.stale)
+        // 等 10 秒后的下一轮轮询补上。重复 stale 仍要进入可恢复状态，
+        // 不能永远停在“正在核对”。
+        if (!("stale" in home.value) || !home.value.stale) {
+          setSummaryFailures(0);
           setSummary(home.value);
+        } else {
+          setSummaryFailures((count) => count + 1);
+        }
       } else {
-        setFailed(true);
+        setSummaryFailures((count) => count + 1);
       }
       if (state.status === "fulfilled") setProcessing(state.value);
       if (sync.status === "fulfilled") setSyncHealth(sync.value);
@@ -578,7 +582,8 @@ export function ApplicationsHome({
   }, [active, requestKey]);
   const visible = summary;
   const latest = visible?.latest;
-  const summaryUnavailable = failed;
+  const summaryUnavailable = visible === null && summaryFailures >= 2;
+  const summaryStale = visible !== null && summaryFailures >= 2;
   const hasCall =
     recentCall !== null &&
     (callState === "ready" || callState === "incomplete");
@@ -642,7 +647,7 @@ export function ApplicationsHome({
       ? t("apps.running")
       : sedimentation?.enabled === false
         ? t("apps.paused")
-        : t("apps.unchecked");
+        : t("apps.checkingStatus");
   const stateDetail =
     sedimentation?.enabled === false
       ? t("apps.stoppedNew")
@@ -821,42 +826,27 @@ export function ApplicationsHome({
               <h2>{t("apps.overview")}</h2>
             </header>
             <div className="r6-home-metrics">
-              <div>
+              <div role="status" aria-live="polite" aria-atomic="true">
                 <p>{t("apps.memories")}</p>
-                {/* The figure slot used to hold the word 读取中 while the first
-                  read was in flight, which is how "大数字不可见" (D51) shows up
-                  on a slow link: the biggest type on the page spends the first
-                  frame saying something that is not a number. A bar of the same
-                  height reserves the digits instead, and the wording moves to a
-                  live region so screen readers still hear it. 暂无法读取 stays a
-                  word, because that is a settled state rather than progress. */}
-                {!visible && !summaryUnavailable ? (
-                  <>
-                    <p className="r6-home-figure">
-                      <span
-                        className="r6-home-figure-pending"
-                        aria-hidden="true"
-                      />
-                    </p>
-                    <small role="status">{t("apps.readingCount")}</small>
-                  </>
-                ) : (
-                  <>
-                    <p className="r6-home-figure">
-                      <strong className={visible ? "" : "r6-home-word"}>
-                        {visible
-                          ? new Intl.NumberFormat(locale).format(
-                              visible.memory_count,
-                            )
-                          : t("apps.unreadable")}
-                      </strong>
-                      {visible && t("apps.unit") ? (
-                        <i>{t("apps.unit")}</i>
-                      ) : null}
-                    </p>
-                    <small>{t("apps.scope")}</small>
-                  </>
-                )}
+                <p className="r6-home-figure">
+                  <strong>
+                    {new Intl.NumberFormat(locale).format(
+                      visible?.memory_count ?? 0,
+                    )}
+                  </strong>
+                  {t("apps.unit") ? <i>{t("apps.unit")}</i> : null}
+                </p>
+                <small>
+                  {visible
+                    ? summaryStale
+                      ? t("apps.showingPrevious")
+                      : t("apps.scope")
+                    : summaryUnavailable
+                      ? t("apps.countWillUpdate")
+                      : summaryFailures
+                        ? t("apps.startingRetry")
+                        : t("apps.readingCount")}
+                </small>
               </div>
               <div>
                 <p>{t("apps.processing")}</p>
@@ -867,12 +857,16 @@ export function ApplicationsHome({
                 <p>{t("apps.recentUpdate")}</p>
                 <strong className={time ? "r6-home-time" : "r6-home-word"}>
                   {time ??
-                    (visible ? t("apps.notGenerated") : t("apps.unchecked"))}
+                    (visible
+                      ? t("apps.notGenerated")
+                      : t("apps.checkingRecent"))}
                 </strong>
                 <small>
                   {time
                     ? `${latestClock?.today ? `${t("apps.today")}· ` : ""}${t("apps.saved")}`
-                    : t("apps.separate")}
+                    : visible
+                      ? t("apps.separate")
+                      : t("apps.recentWillUpdate")}
                 </small>
               </div>
             </div>
@@ -972,7 +966,9 @@ export function ApplicationsHome({
                               .join(" · ")
                           : activity === "importing"
                             ? t("apps.savingConversations")
-                            : t("apps.waitingMemories")}
+                            : activity === "loading"
+                              ? t("apps.recentWillUpdate")
+                              : t("apps.waitingMemories")}
                   </small>
                 </section>
                 {(activity === "unavailable" ||

memhub/apps/web/src/DebugLogPanel.tsx

@@ -50,7 +50,6 @@ const SERVICE_LABELS: Record<DebugLogEntry["service"], string> = {
   core: "Core",
   "host-bridge": "Host Bridge",
   cli: "CLI",
-  "hy-memory": "HY Memory",
 };
 
 export function DebugLogPanel() {

memhub/apps/web/src/LanguageSelector.test.tsx

@@ -1,11 +1,18 @@
 // @vitest-environment jsdom
 
 import { translate } from "@one-memory/i18n";
-import { cleanup, render, screen } from "@testing-library/react";
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { afterEach, expect, it, vi } from "vitest";
 import { LANGUAGE_STORAGE_KEY, LanguageProvider } from "./gui-language";
 import { LanguageSelector } from "./LanguageSelector";
+import { optionMenuPosition } from "./OptionMenu";
 
 afterEach(() => {
   cleanup();
@@ -159,3 +166,141 @@ it("announces storage errors without replacing the confirmed choice", async () =
     "zh-CN",
   );
 });
+
+it("keeps a right-edge menu inside the viewport", () => {
+  expect(
+    optionMenuPosition(
+      { top: 8, right: 1016, bottom: 40, left: 872, width: 144 },
+      160,
+      1024,
+      600,
+    ),
+  ).toMatchObject({
+    top: 44,
+    left: 868,
+    width: 144,
+    maxHeight: 280,
+    placement: "below",
+  });
+});
+
+it("flips the menu above when the lower edge has no room", () => {
+  expect(
+    optionMenuPosition(
+      { top: 540, right: 500, bottom: 572, left: 356, width: 144 },
+      180,
+      1024,
+      600,
+    ),
+  ).toMatchObject({
+    top: 356,
+    left: 356,
+    width: 144,
+    maxHeight: 280,
+    placement: "above",
+  });
+});
+
+it("limits the panel to the actual space when neither side has 280px", () => {
+  expect(
+    optionMenuPosition(
+      { top: 40, right: 160, bottom: 60, left: 16, width: 144 },
+      180,
+      320,
+      100,
+    ),
+  ).toMatchObject({
+    top: 64,
+    left: 16,
+    width: 144,
+    maxHeight: 24,
+    placement: "below",
+  });
+});
+
+it("portals the open menu outside clipping layout containers", async () => {
+  render(
+    <LanguageProvider>
+      <div data-testid="clipping-parent">
+        <LanguageSelector compact />
+      </div>
+    </LanguageProvider>,
+  );
+  await userEvent.click(screen.getByRole("combobox"));
+  const listbox = screen.getByRole("listbox");
+  expect(listbox.parentElement).toBe(document.body);
+  expect(
+    listbox.classList.contains("r6-language-option-menu-panel--compact"),
+  ).toBe(true);
+});
+
+it("keeps the menu open while its portal scrollbar or padding is pressed", async () => {
+  render(
+    <LanguageProvider>
+      <LanguageSelector compact />
+    </LanguageProvider>,
+  );
+  const selector = screen.getByRole("combobox");
+  await userEvent.click(selector);
+  const listbox = screen.getByRole("listbox");
+  fireEvent.mouseDown(listbox);
+  fireEvent.blur(selector, { relatedTarget: null });
+  expect(selector.getAttribute("aria-expanded")).toBe("true");
+  fireEvent.mouseUp(document);
+});
+
+it("clears the portal pointer guard when the menu closes mid-press", async () => {
+  render(
+    <LanguageProvider>
+      <LanguageSelector compact />
+    </LanguageProvider>,
+  );
+  const selector = screen.getByRole("combobox");
+  await userEvent.click(selector);
+  fireEvent.mouseDown(screen.getByRole("listbox"));
+  fireEvent.keyDown(document, { key: "Escape" });
+  expect(selector.getAttribute("aria-expanded")).toBe("false");
+
+  await userEvent.click(selector);
+  fireEvent.blur(selector, { relatedTarget: null });
+  expect(selector.getAttribute("aria-expanded")).toBe("false");
+});
+
+it("clears the portal pointer guard when the window loses focus", async () => {
+  render(
+    <LanguageProvider>
+      <LanguageSelector compact />
+    </LanguageProvider>,
+  );
+  const selector = screen.getByRole("combobox");
+  await userEvent.click(selector);
+  fireEvent.mouseDown(screen.getByRole("listbox"));
+  fireEvent.blur(window);
+  fireEvent.blur(selector, { relatedTarget: null });
+  expect(selector.getAttribute("aria-expanded")).toBe("false");
+});
+
+it("closes the portal when its anchor scrolls completely out of view", async () => {
+  render(
+    <LanguageProvider>
+      <LanguageSelector compact />
+    </LanguageProvider>,
+  );
+  const selector = screen.getByRole("combobox");
+  vi.spyOn(selector, "getBoundingClientRect").mockReturnValue({
+    top: 20,
+    right: 1168,
+    bottom: 52,
+    left: 1024,
+    width: 144,
+    height: 32,
+    x: 1024,
+    y: 20,
+    toJSON: () => ({}),
+  });
+  await userEvent.click(selector);
+  await waitFor(() =>
+    expect(selector.getAttribute("aria-expanded")).toBe("false"),
+  );
+  expect(screen.queryByRole("listbox")).toBeNull();
+});

memhub/apps/web/src/LanguageSelector.tsx

@@ -54,6 +54,11 @@ export function LanguageSelector({ compact = false }: { compact?: boolean }) {
           disabled={pending}
           options={options}
           className="r6-language-option-menu"
+          panelClassName={
+            compact
+              ? "r6-language-option-menu-panel--compact"
+              : "r6-language-option-menu-panel--settings"
+          }
           onChange={async (value) => {
             if (!isLanguagePreference(value)) return;
             setPending(true);