fix(web): distinguish scanned and saved imports

Co-authored-by: Cursor <cursoragent@cursor.com>

CHANGELOG.md

@@ -14,11 +14,6 @@ Hy Memory and MemHub are versioned and released independently.
 
 ## Unreleased
 
-- Clarified that `add(metadata=...)` carries legacy SDK processing options,
-  while persistent caller business context belongs in `meta`.
-- Added an opt-in `get(..., include_raw=True)` path for reading `L1_RAW`
-  memories, including memories written in lite mode. The default remains
-  hidden for backward compatibility.
 - Removed MemHub's task-scoped HyPermission store wrappers and global
   model-content consent switch. The trusted embedded Hy Memory SDK now uses
   its native local stores directly.

docs/usage.md

@@ -106,15 +106,6 @@ result = client.add(
 )
 ```
 
-`metadata` 与 `meta` 不是同一字段：
-
-- `metadata` 是兼容旧调用方保留的 SDK 处理选项，会进入内部
-  `WriteRequest.extra`，不保证持久化或随查询结果返回。
-- `meta` 是调用方的业务上下文，会持久化并在 `search()`、`get()` 等结果中返回。
-  同一记忆被多次合并时，各次 `meta` 会按写入顺序保存在列表中。
-
-需要以后读回的数据必须放在 `meta`，不要放在 `metadata`。
-
 `scene` 的公开取值：
 
 - `None`：普通文本直接走 chat；messages 含 tool 时执行快速场景判断。
@@ -272,8 +263,6 @@ catalog 也可以在没有基础 L0 时形成只读的合成画像。
 
 ```python
 memory = client.get("memory_id")
-# lite 模式写入的是 L1_RAW；按 ID 读取时必须显式选择返回原文。
-raw_memory = client.get("memory_id", include_raw=True)
 result = client.update("memory_id", "更新后的内容")
 result = client.delete("memory_id")
 result = client.delete_all(user_id="user_001")
@@ -293,10 +282,6 @@ result = client.clone_user("user_001", "user_002", agent_id=None)
 对应异步方法为 `async_get()`、`async_update()`、`async_delete()`、
 `async_delete_all()`、`async_list_memories()`、`async_clone_user()`。
 
-`get()` / `async_get()` 默认继续隐藏 `L1_RAW`，因此不会改变现有调用方的原文访问
-边界。只有显式传入 `include_raw=True` 才返回该层；这也是 lite 模式按 ID 读取
-写入内容及其 `meta` 的方式。MemHub 的 HTTP 读取接口不开放此参数。
-
 普通 `list_memories()` 返回 `vdb` 桶，并在 Graph 有结果时附带 `graph`；传入
 `workspace_id` 时返回生产力记忆的 `scene="productivity"` 和 `experiences`。
 

hy_memory/client.py

@@ -1597,9 +1597,7 @@ class HyMemoryClient:
             session_id:   Session ID（三级隔离 key）
             source:       调用来源，例如 openclaw / cursor / codex；与 agent_id 正交。
                           写入前执行 strip().lower()，默认 "default"。
-            metadata:     旧版 SDK 处理选项，会并入内部 WriteRequest.extra。
-                          不保证持久化或随查询返回；调用方需要保存并读回的业务字段
-                          请使用 meta。
+            metadata:     自定义元数据
             memory_at:    记忆时间戳（不传则用当前时间），用于导入历史记忆
             scene:        显式指定写入路由，跳过 LLM 自动判定。
                           - None（默认）：含 tool 时 LLM 判 chat/working/coding；
@@ -1625,8 +1623,8 @@ class HyMemoryClient:
             branch:       Coding memory 路径专用。分支名。同 workspace_id。chat 路径忽略。
             meta:         调用方自定义业务 meta，随本次产出的记忆存储、查询时原样返回。
                           不 embed、不参与召回、不作过滤条件。
-                          与 metadata 不同：metadata 是旧版内部处理选项，
-                          meta 独立持久化，只做业务透传。
+                          与 metadata 不同：metadata 会并入 extra（含 SDK 内部控制键），
+                          meta 独立存放，只做透传。
                           语义为「该次 write 时刻的上下文」，故存为 list——同一节点被
                           多次写入合并时会追加而非覆盖，详见 get() 返回的 meta 字段。
 
@@ -1793,26 +1791,17 @@ class HyMemoryClient:
             query_embedding=query_embedding,
         ))
 
-    def get(
-        self,
-        memory_id: str,
-        *,
-        include_raw: bool = False,
-    ) -> Optional[Dict[str, Any]]:
+    def get(self, memory_id: str) -> Optional[Dict[str, Any]]:
         """
         获取单条记忆。
 
         Args:
             memory_id: 记忆 ID
-            include_raw: 是否允许返回 L1_RAW 原始记忆。默认 False，保持原有隐藏行为；
-                         lite 模式的记忆均为 L1_RAW，需显式设为 True 才能按 ID 读取。
 
         Returns:
             {"memory_id", "content", "layer", "request_id", "elapsed_ms"} 或 None（不存在时）
         """
-        return self._loop_thread.run(
-            self.async_get(memory_id, include_raw=include_raw)
-        )
+        return self._loop_thread.run(self.async_get(memory_id))
 
     def update(
         self,
@@ -3661,21 +3650,12 @@ class HyMemoryClient:
     # ================================================================
 
     @_ensure_internal_loop
-    async def async_get(
-        self,
-        memory_id: str,
-        *,
-        include_raw: bool = False,
-    ) -> Optional[Dict[str, Any]]:
+    async def async_get(self, memory_id: str) -> Optional[Dict[str, Any]]:
         """
         获取单条记忆（异步）。
 
         VDB + Graph 双路并行查询，哪个有结果返回哪个。
 
-        Args:
-            memory_id: 记忆 ID
-            include_raw: 是否允许返回 L1_RAW 原始记忆，默认 False。
-
         Returns:
             {"memory_id", "content", "layer", "source", "request_id", "elapsed_ms"} 或 None
         """
@@ -3703,24 +3683,17 @@ class HyMemoryClient:
 
         vdb_node, graph_node = await _asyncio_get.gather(_get_vdb(), _get_graph())
 
-        # L1_RAW 默认不对外可见：按 ID 直取走主键查询、绕过向量库的 layer
-        # filter，故在此统一挡掉。SDK 调用方可通过 include_raw=True 显式读取；
-        # HTTP 接口不传该参数，继续保持隐藏。内部写链路不经过此方法。
+        # L1_RAW 不对外可见：按 ID 直取走主键查询、绕过向量库的 layer filter，
+        # 故在此统一挡掉。async_get 是 GET /v1/memories/{id} 与
+        # /v1/memories/batch 两个对外接口的共同必经处，而内部写链路不经过它
+        # （writer 写后校验直接调 vector_store.get_by_id），挡在此处不影响内部。
         #
         # 置于 gather 之后、埋点之前：命中 raw 仍照常落 GET 埋点（保留可观测性，
         # 便于发现有调用方拿 raw id 试探），只是不把内容返回给调用方。
         # 对调用方的表现与"该 id 不存在"完全一致，不额外暴露"存在但被挡"的信息。
-        if (
-            not include_raw
-            and vdb_node is not None
-            and vdb_node.layer == MemoryLayer.L1_RAW
-        ):
+        if vdb_node is not None and vdb_node.layer == MemoryLayer.L1_RAW:
             vdb_node = None
-        if (
-            not include_raw
-            and graph_node is not None
-            and getattr(graph_node, "layer", None) == MemoryLayer.L1_RAW
-        ):
+        if graph_node is not None and getattr(graph_node, "layer", None) == MemoryLayer.L1_RAW:
             graph_node = None
 
         elapsed = round((time.perf_counter() - t0) * 1000, 2)

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

@@ -2793,12 +2793,6 @@ def create_app(
         # D75: work queued for the previous model continues with this one.
         # Only tasks that never reached the model are re-bound.
         await asyncio.to_thread(app.state.memory_task_store.rebind_unstarted_profile, profile)
-        # A missing profile is an event-driven wait, not a provider outage.
-        # Release those durable rows only now that activation has changed the
-        # condition; the ordinary drain poll will claim them without a restart.
-        await asyncio.to_thread(
-            app.state.memory_write_queue.readmit_model_profile_waiters
-        )
         # Not awaited: the catch-up reads every conversation ever imported, and
         # the answer to "which profile is active" does not depend on it.
         _start_backfill(app)
@@ -5068,11 +5062,10 @@ def _source_writes_on(app: FastAPI, source_id: str) -> bool:
 
 
 def _sedimentation_claim_enabled(app: FastAPI, source_id: str) -> bool:
-    """Claim queued model work only when policy, source and model all admit it."""
+    """Claim queued model work only while both global and source gates allow it."""
 
     return (
         _config_store(app).sedimentation_enabled()
-        and _model_profile_store(app).active_identity() is not None
         and _history_import_gate_released(app)
         and _source_writes_on(app, source_id)
     )

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

@@ -282,24 +282,11 @@ class PollingLiveSyncSupervisor:
                 and job.status
                 in {ImportStatus.PENDING, ImportStatus.RUNNING, ImportStatus.INTERRUPTED}
             ]
-            bounded_history_incomplete = any(
-                job.source_id == source_id
-                and job.operation == "history"
-                and job.history_after is not None
-                and job.status is not ImportStatus.COMPLETED
-                for job in source_jobs
-            )
             # Establish the realtime EOF independently even while history owns
             # this source. Otherwise the P1 job starts from the P2 checkpoint
             # (or from zero) and becomes a second full-history scan.
             adapter = self.import_supervisor.adapters[source_id]
-            live_cursors = await self._live_cursors(source_id, adapter)
-            # A bounded onboarding history is the authority for everything up
-            # to its EOF. An adapter without a native live baseline has no safe
-            # realtime cursor until that history finishes; starting a sync from
-            # zero here would bypass `history_after` and import the old corpus.
-            if bounded_history_incomplete and not live_cursors:
-                return None
+            await self._live_cursors(source_id, adapter)
             # Only one scan of a source may be in flight: they share the
             # cursor, and two readers means every file read twice. With a
             # catch-up still holding the source there is no free moment to ask

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

@@ -1404,12 +1404,11 @@ class DurableWriteQueue:
     ) -> int:
         """Re-admit `waiting_for_model` jobs whose wait has elapsed.
 
-        A model outage clears on its own, so transient waiters retry on a timer
+        A model outage clears on its own, so this state is retried on a timer
         rather than waiting for a grant event like `waiting_for_permission`.
-        `model_profile_not_active` is excluded: only explicit activation can
-        change that condition. Keyed on `updated_at` so repeated calls while a
-        job is still parked do not reset its own clock; the attempt consumed by
-        the parking claim is returned, the same way `readmit_parked` does.
+        Keyed on `updated_at` so repeated calls while a job is still parked do
+        not reset its own clock; the attempt consumed by the parking claim is
+        returned, the same way `readmit_parked` does.
         """
         now = now or datetime.now(UTC)
         threshold = (now - after).isoformat()
@@ -1418,33 +1417,8 @@ class DurableWriteQueue:
                 "UPDATE memory_write_jobs SET state=?, lease_owner=NULL, "
                 "lease_expires_at=NULL, attempts=CASE WHEN attempts>0 "
                 "THEN attempts-1 ELSE 0 END, last_error=NULL, updated_at=? "
-                "WHERE state=? AND updated_at <= ? AND hy_invoked=0 "
-                "AND (last_error IS NULL OR last_error<>?)",
-                (
-                    PENDING,
-                    now.isoformat(),
-                    WAITING_FOR_MODEL,
-                    threshold,
-                    "model_profile_not_active",
-                ),
-            )
-        return changed.rowcount
-
-    def readmit_model_profile_waiters(self) -> int:
-        """Re-admit no-profile work only after model activation changes the condition."""
-        now = datetime.now(UTC).isoformat()
-        with main_database(self.database_path).write() as connection, connection:
-            changed = connection.execute(
-                "UPDATE memory_write_jobs SET state=?, lease_owner=NULL, "
-                "lease_expires_at=NULL, attempts=CASE WHEN attempts>0 "
-                "THEN attempts-1 ELSE 0 END, last_error=NULL, updated_at=? "
-                "WHERE state=? AND last_error=? AND hy_invoked=0",
-                (
-                    PENDING,
-                    now,
-                    WAITING_FOR_MODEL,
-                    "model_profile_not_active",
-                ),
+                "WHERE state=? AND updated_at <= ? AND hy_invoked=0",
+                (PENDING, now.isoformat(), WAITING_FOR_MODEL, threshold),
             )
         return changed.rowcount
 
@@ -2097,12 +2071,7 @@ async def execute_job(
         # Never `logger.exception` here: it prints the exception's message,
         # which may be a provider response or the user's own text. Log the
         # already-sanitised code instead, matching `hy-failure-classification`.
-        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)
-        else:
-            logger.error("durable_write_job_failed job_id=%s error_code=%s", job_id, code)
+        logger.error("durable_write_job_failed job_id=%s error_code=%s", job_id, code)
         return
     await in_the_background(queue.settle, job_id, state=COMPLETED, owner=owner)
 

memhub/apps/core/tests/test_live_sync.py

@@ -94,67 +94,6 @@ class SettledFixtureAdapter(IncrementalFixtureAdapter):
         }
 
 
-class BoundedOnboardingAdapter:
-    """No native baseline: bounded history must establish the live cursor."""
-
-    descriptor = IncrementalFixtureAdapter.descriptor
-
-    def __init__(self) -> None:
-        self.include_new = False
-
-    async def detect(self) -> bool:
-        return True
-
-    async def scan(self, options: ScanOptions):
-        current = options.cursors.get("e" * 64)
-        checkpoint = current.checkpoint if current is not None else None
-        if checkpoint not in {"byte:10", "byte:20"}:
-            yield ScannedEvidence(
-                evidence=EvidenceInput(
-                    source_id="fixture",
-                    conversation_id="old-conversation",
-                    message_id="old-message",
-                    role="user",
-                    written_by=WrittenBy.PERSON,
-                    created_at=datetime(2020, 1, 1, tzinfo=UTC),
-                    verbatim="old history",
-                    origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
-                ),
-                cursor=SourceCursor(
-                    file_key="e" * 64,
-                    file_identity="bounded",
-                    checkpoint="byte:10",
-                    checkpoint_anchor="f" * 64,
-                    observed_size=20,
-                    observed_modified_ns=1,
-                ),
-            )
-            checkpoint = "byte:10"
-        if self.include_new and checkpoint != "byte:20":
-            yield ScannedEvidence(
-                evidence=EvidenceInput(
-                    source_id="fixture",
-                    conversation_id="new-conversation",
-                    message_id="new-message",
-                    role="user",
-                    written_by=WrittenBy.PERSON,
-                    created_at=datetime(2026, 10, 18, tzinfo=UTC),
-                    verbatim="new append",
-                    origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
-                ),
-                cursor=SourceCursor(
-                    file_key="e" * 64,
-                    file_identity="bounded",
-                    checkpoint="byte:20",
-                    checkpoint_anchor="1" * 64,
-                    observed_size=20,
-                    observed_modified_ns=2,
-                    read_to_end=True,
-                ),
-            )
-        yield ScanProgressEvent(phase=ScanPhase.DONE)
-
-
 class HoldingHistoryAdapter:
     """First scan blocks until cancelled; later scans yield one new record."""
 
@@ -389,56 +328,6 @@ def test_live_sync_does_not_resume_a_history_import_the_user_paused(tmp_path) ->
     asyncio.run(scenario())
 
 
-def test_bounded_onboarding_history_establishes_cursor_before_first_sync(tmp_path) -> None:
-    async def scenario() -> None:
-        database = tmp_path / "one-memory.sqlite3"
-        evidence = EvidenceStore(database)
-        jobs = ImportJobStore(database)
-        adapter = BoundedOnboardingAdapter()
-        imports = ImportSupervisor(
-            adapters={"fixture": adapter},
-            evidence_store=evidence,
-            job_store=jobs,
-        )
-        live_sync = PollingLiveSyncSupervisor(
-            source_ids=("fixture",),
-            import_supervisor=imports,
-            job_store=jobs,
-        )
-        history = imports.create_job("fixture", operation="history")
-        with sqlite3.connect(database) as connection, connection:
-            connection.execute(
-                "UPDATE import_jobs SET history_after=? WHERE job_id=?",
-                (datetime(2026, 10, 15, tzinfo=UTC).isoformat(), history.job_id),
-            )
-
-        # With no native baseline, sync must wait instead of scanning from zero
-        # and bypassing the onboarding history window.
-        assert await live_sync.trigger("fixture") is None
-        assert not [job for job in jobs.list_jobs() if job.operation == "sync"]
-
-        imports.enqueue(history.job_id)
-        completed = await imports.wait(history.job_id)
-        assert completed.status is ImportStatus.COMPLETED
-        assert completed.stored == 0
-        assert completed.skipped == 1
-        assert evidence.count() == 0
-
-        # Once bounded history has advanced the cursor to EOF, normal realtime
-        # appends are admitted without retaining the three-day cutoff forever.
-        adapter.include_new = True
-        synced = await live_sync.trigger("fixture")
-        assert synced is not None
-        assert synced.status is ImportStatus.COMPLETED
-        assert synced.stored == 1
-        records = evidence.list_extractable()
-        assert [record.verbatim for record in records] == ["new append"]
-        await live_sync.shutdown()
-        await imports.shutdown()
-
-    asyncio.run(scenario())
-
-
 def test_a_sync_left_running_after_its_worker_died_is_started_again(tmp_path) -> None:
     """A running row with no live worker used to be returned as 'already syncing'.
 

memhub/apps/core/tests/test_memory_server_durable_queue.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import json
-import logging
 import sqlite3
 import threading
 import time
@@ -1370,30 +1369,24 @@ def test_a_machine_error_code_is_preserved(tmp_path) -> None:
     assert safe_error_code(ValueError("some sentence with spaces")) == "ValueError"
 
 
-def test_an_inactive_profile_parks_without_error_logging(tmp_path, caplog) -> None:
+def test_an_inactive_profile_parks_for_model_before_any_send(tmp_path) -> None:
     """A pre-bridge model-not-ready code parks and keeps the intent."""
     path = tmp_path / "one-memory.sqlite3"
     queue = DurableWriteQueue(path)
     record = queue.submit(_request())
     _claim_through_drain(queue, record.job_id)
 
-    with caplog.at_level(
-        logging.DEBUG,
-        logger="one_memory.memory_server.durable_queue",
-    ):
-        asyncio.run(
-            execute_job(
-                record.job_id,
-                queue=queue,
-                supervisor=_Recorder(error=RuntimeError("model_profile_not_active")),
-                evidence=_EvidenceStore({"e1"}),
-            )
+    asyncio.run(
+        execute_job(
+            record.job_id,
+            queue=queue,
+            supervisor=_Recorder(error=RuntimeError("model_profile_not_active")),
+            evidence=_EvidenceStore({"e1"}),
         )
+    )
 
     assert _state(path, record.job_id) == WAITING_FOR_MODEL
     assert _rows(path)[0]["hy_invoked"] == 0
-    assert "durable_write_job_failed" not in caplog.text
-    assert "durable_write_job_parked" in caplog.text
 
 
 def test_an_authorization_stop_cancels_instead_of_failing(tmp_path) -> None:
@@ -1553,7 +1546,7 @@ def test_parking_does_not_burn_the_retry_budget(tmp_path) -> None:
     assert queue.get("idem-1").state == PENDING
 
 
-def test_a_transient_model_waiter_is_readmitted_once_its_wait_elapses(tmp_path) -> None:
+def test_a_model_waiter_is_readmitted_once_its_wait_elapses(tmp_path) -> None:
     """A model outage clears on its own; nothing re-admits it otherwise.
 
     `waiting_for_permission` needs a grant event, but `waiting_for_model` is
@@ -1571,7 +1564,7 @@ def test_a_transient_model_waiter_is_readmitted_once_its_wait_elapses(tmp_path)
     queue.settle(
         record.job_id,
         state=WAITING_FOR_MODEL,
-        error_code="model_secret_unavailable",
+        error_code="model_profile_not_active",
         hy_invoked=False,
     )
 
@@ -1588,8 +1581,8 @@ def test_a_transient_model_waiter_is_readmitted_once_its_wait_elapses(tmp_path)
     assert _rows(path)[0]["attempts"] == 0
 
 
-def test_no_profile_waiter_is_readmitted_only_after_activation(tmp_path) -> None:
-    """No timer can create a model profile; activation owns this transition."""
+def test_readmitting_a_model_waiter_clears_its_stale_detail(tmp_path) -> None:
+    """The timer readmission path must clear the old blocking reason too."""
     path = tmp_path / "one-memory.sqlite3"
     queue = DurableWriteQueue(path)
     record = queue.submit(_request())
@@ -1601,50 +1594,13 @@ def test_no_profile_waiter_is_readmitted_only_after_activation(tmp_path) -> None
     )
     now = datetime.now(UTC)
 
-    assert queue.readmit_model_waiters(now=now + timedelta(minutes=2)) == 0
-    parked = queue.get("idem-1")
-    assert parked.state == WAITING_FOR_MODEL
-    assert parked.detail == "model_profile_not_active"
+    assert queue.readmit_model_waiters(now=now + timedelta(minutes=2)) == 1
 
-    assert queue.readmit_model_profile_waiters() == 1
     readmitted = queue.get("idem-1")
     assert readmitted.state == PENDING
     assert readmitted.detail == ""
 
 
-def test_no_profile_backlog_stays_parked_across_maintenance_cycles(tmp_path) -> None:
-    path = tmp_path / "one-memory.sqlite3"
-    queue = DurableWriteQueue(path)
-    for index in range(100):
-        record = queue.submit(_request(key=f"no-profile-{index}"))
-        queue.settle(
-            record.job_id,
-            state=WAITING_FOR_MODEL,
-            error_code="model_profile_not_active",
-            hy_invoked=False,
-        )
-    with sqlite3.connect(path) as connection, connection:
-        connection.execute(
-            "UPDATE memory_write_jobs SET attempts=1,"
-            "updated_at='2000-01-01T00:00:00+00:00'"
-        )
-
-    first = datetime.now(UTC)
-    assert queue.readmit_model_waiters(now=first, after=timedelta(0)) == 0
-    assert (
-        queue.readmit_model_waiters(
-            now=first + timedelta(minutes=2),
-            after=timedelta(0),
-        )
-        == 0
-    )
-    with sqlite3.connect(path) as connection:
-        assert connection.execute(
-            "SELECT state,attempts,COUNT(*) FROM memory_write_jobs "
-            "GROUP BY state,attempts"
-        ).fetchall() == [(WAITING_FOR_MODEL, 1, 100)]
-
-
 def test_readmit_parked_cannot_resurrect_a_terminal_row(tmp_path) -> None:
     """Only parked states may be re-admitted, never a finished write.
 

memhub/apps/core/tests/test_model_profile_api.py

@@ -259,17 +259,12 @@ def test_activation_survives_a_corpus_already_imported(tmp_path) -> None:
                 ),
                 secrets=secrets,
             )
-            readmissions: list[bool] = []
-            app.state.memory_write_queue.readmit_model_profile_waiters = (
-                lambda: readmissions.append(True) or 0
-            )
 
             activated = await client.post(f"/api/v1/model-profiles/{profile_id}/activate")
 
             assert activated.status_code == 200
             assert activated.json()["is_active"] is True
             assert API_KEY not in activated.text
-            assert readmissions == [True]
             # Started, not waited for: the walk reads every conversation.
             assert not app.state.memory_backfill.done()
 

memhub/apps/core/tests/test_policy_api_wiring.py

@@ -111,9 +111,6 @@ def test_the_manual_source_is_admitted_by_grant_without_a_toggle(tmp_path) -> No
     app = SimpleNamespace(
         state=SimpleNamespace(
             config_store=config,
-            model_profile_store=SimpleNamespace(
-                active_identity=lambda: ("profile", 1)
-            ),
             source_grant_store=SimpleNamespace(
                 receipt=lambda **_kwargs: SimpleNamespace(revoked_at=None)
             ),
@@ -128,21 +125,6 @@ def test_the_manual_source_is_admitted_by_grant_without_a_toggle(tmp_path) -> No
     assert _sedimentation_claim_enabled(app, "one-memory-manual") is False
 
 
-def test_claim_gate_waits_without_polling_when_no_model_is_active(tmp_path) -> None:
-    config = ConfigStore(tmp_path)
-    app = SimpleNamespace(
-        state=SimpleNamespace(
-            config_store=config,
-            model_profile_store=SimpleNamespace(active_identity=lambda: None),
-            source_grant_store=SimpleNamespace(
-                receipt=lambda **_kwargs: SimpleNamespace(revoked_at=None)
-            ),
-        )
-    )
-
-    assert _sedimentation_claim_enabled(app, "one-memory-manual") is False
-
-
 def test_first_import_gate_waits_for_every_selected_history_job() -> None:
     state = SimpleNamespace(
         status="importing",

tests/test_block_l1_raw_in_read_filter.py

@@ -12,9 +12,8 @@ L1_RAW 对外读路径不可见：闸门焊在向量库唯一查询入口。
 hybrid_search_native / list_by_user 四个查询方法的共同必经处，
 上层无法绕开，新增接口自动受保护。
 
-按 ID 直取走主键查询、不经过 filter，故在 `client.async_get` 处默认挡住。
-Python SDK 调用方可显式传 `include_raw=True` 读取；HTTP 接口不传该参数，
-继续保持原有隐藏行为。
+按 ID 直取走主键查询、不经过 filter，故在 `client.async_get` 处单独挡
+（GET /v1/memories/{id} 与 /v1/memories/batch 的共同必经处）。
 
 内部管线需读原始对话时显式 allow_raw_layer=True 放行：
 - `writer._get_recent_dialogue_history`：提取前拼多轮对话历史喂 LLM
@@ -125,63 +124,28 @@ class TestListNoLongerFiltersInProcess:
             "list 又出现进程内过滤 raw 的写法，应交由 vdb 侧 filter 完成"
 
 
-class TestGetByIdRawOptIn:
-    """按 ID 直取默认隐藏 raw，只有 SDK 显式选择时才返回。"""
+class TestGetByIdPathBlocksRaw:
+    """按 ID 直取：走主键查询不经 filter，须在 async_get 处挡住。"""
 
-    @staticmethod
-    def _client(node):
-        from hy_memory.client import HyMemoryClient
-
-        class Store:
-            async def get_by_id(self, memory_id):
-                return node if memory_id == node.node_id else None
-
-        async def no_op_log(**kwargs):
-            return None
-
-        client = HyMemoryClient.__new__(HyMemoryClient)
-        client._vector_store = Store()
-        client._graph_store = None
-        client._backend_identity = lambda: {}
-        client._maybe_store_op_log = no_op_log
-        return client
-
-    @staticmethod
-    def _raw_node():
-        return MemoryNode(
-            node_id="raw-1",
-            user_id="u1",
-            agent_id="a1",
-            session_id="s1",
-            content="原始对话",
-            layer=MemoryLayer.L1_RAW,
-            status=MemoryStatus.ACTIVE,
-            custom={"meta": [{"source": "test"}]},
-        )
-
-    def test_default_still_hides_raw(self):
-        from hy_memory.client import HyMemoryClient
-
-        client = self._client(self._raw_node())
-        raw_get = HyMemoryClient.async_get.__wrapped__
-        assert run(raw_get(client, "raw-1")) is None
-
-    def test_explicit_include_raw_returns_lite_memory(self):
-        from hy_memory.client import HyMemoryClient
-
-        client = self._client(self._raw_node())
-        raw_get = HyMemoryClient.async_get.__wrapped__
-        result = run(raw_get(client, "raw-1", include_raw=True))
-
-        assert result["memory_id"] == "raw-1"
-        assert result["content"] == "原始对话"
-        assert result["layer"] == MemoryLayer.L1_RAW.value
-        assert result["meta"] == [{"source": "test"}]
-
-    def test_public_get_exposes_keyword_only_opt_in(self):
+    def test_async_get_drops_raw_node(self):
         import inspect
         from hy_memory.client import HyMemoryClient
+        src = inspect.getsource(HyMemoryClient.async_get)
+        assert "MemoryLayer.L1_RAW" in src, \
+            "async_get 未挡 raw，batch 与按 ID 单取会漏出原始对话"
 
-        param = inspect.signature(HyMemoryClient.get).parameters["include_raw"]
-        assert param.default is False
-        assert param.kind is inspect.Parameter.KEYWORD_ONLY
+    def test_block_happens_before_return(self):
+        """挡的位置必须在两处 return 之前，否则等于没挡。"""
+        import inspect
+        from hy_memory.client import HyMemoryClient
+        lines = inspect.getsource(HyMemoryClient.async_get).splitlines()
+        block_at = next(
+            i for i, l in enumerate(lines)
+            if "MemoryLayer.L1_RAW" in l and "vdb_node" in l
+        )
+        first_return_at = next(
+            i for i, l in enumerate(lines)
+            if l.strip().startswith("return {")
+        )
+        assert block_at < first_return_at, \
+            f"挡 raw 在第 {block_at} 行、首个 return 在第 {first_return_at} 行，顺序错了"