Merge remote-tracking branch 'origin/main' into fix/restore-open-source-model-setup-ui

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

CHANGELOG.md

@@ -4,6 +4,27 @@ Hy Memory and MemHub are versioned and released independently.
 
 ## Unreleased
 
+- MemHub host capture hooks no longer write the database. `one-memory
+  capture <host>` used to open the main SQLite file from its own short-lived
+  process on every hook, re-create the retired `evidence` / FTS tables on an
+  SDK-authority home and write the write queue outside Core's single writer,
+  contending for the file lock with Core and with other hosts' hooks. It now
+  reads only the runtime receipt and token and posts the hook's JSON to the
+  running Core (`POST /api/v1/live-capture/{source}`, 1.5 s budget). Core
+  applies the same gates (grant, sync switch, rejection counting, automated
+  sessions, the Cursor/Claude Code rule; the migration fence stays on the hook
+  side) and stages the turn in-process through the live file-sync path. When
+  Core is not running the turn is dropped silently; nothing falls back to a
+  local write.
+- MemHub no longer sends one turn to the SDK twice when a host's hook and live
+  file sync both see it. The two lanes gave the same message different
+  identities (the hook carries no workspace and often no message id) and
+  separate assembly rows, so both were written as raws. Hook input for a
+  source that live sync reads from its own files (every hooked host except
+  Qwen Work, while live sync is on) is now left to the file path; only a
+  source without file polling is staged from its hook. Tables an older hook
+  re-created on an SDK home are dropped by the existing startup cleanup.
+
 ## Hy Memory 2.0.14 — 2026-11-04
 
 - `search()` / `async_search()` take an optional `statuses` for explicit
@@ -84,7 +105,7 @@ Hy Memory and MemHub are versioned and released independently.
 
 ## MemHub 1.0.6 — 2026-11-04
 
-Build 41, on `hy-memory==2.0.14`. Linux x64/arm64 Runtime and macOS arm64
+Build 43, on `hy-memory==2.0.14`. Linux x64/arm64 Runtime and macOS arm64
 App and Runtime.
 
 - MemHub App now exposes the complete memory-mode lifecycle. New installs

memhub/README.md

@@ -19,7 +19,7 @@ If you run into a problem, please open an Issue with the version, platform,repro
 ## 发行与平台合同
 
 源码当前固定使用公开 PyPI 正式版 `hy-memory==2.0.14`。MemHub 源码版本为 `1.0.6`
-（build 41），GitHub 仓库为
+（build 43），GitHub 仓库为
 [`Tencent-Hunyuan/Hy-Memory`](https://github.com/Tencent-Hunyuan/Hy-Memory)，npm 包名为
 `memhub-cli`。当前代码架构见
 [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md)。

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

@@ -21,7 +21,7 @@ from datetime import UTC, datetime, timedelta
 from functools import partial
 from pathlib import Path
 from typing import Any, Literal, cast
-from uuid import UUID
+from uuid import UUID, uuid4
 
 from fastapi import (
     Depends,
@@ -644,11 +644,42 @@ class SdkRawPage(BaseModel):
     offset: int = Field(ge=0)
     limit: int = Field(ge=1, le=500)
     unit: Literal["raw", "turn"] = "raw"
+    next_cursor: str | None = None
+    has_more: bool = False
+    total_exact: bool = True
     #: Set when a time filter was applied in Core. For storage `raw`, `total`
     #: remains the SDK count; for product `turn`, it is the filtered turn count.
     time_filtered: bool = False
 
 
+class SdkRawGraphItem(BaseModel):
+    """Small, non-authoritative projection used to draw the complete raw map."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    turn_id: str = Field(min_length=1, max_length=96)
+    raw_id: str = Field(min_length=1)
+    label: str = Field(max_length=240)
+    source: str
+    session_id: str
+    memory_at: float | None = None
+    gmt_created: float | None = None
+
+
+class SdkRawGraphPage(BaseModel):
+    """One page from a complete, bounded-memory raw-turn catalog."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    user_id: str
+    items: tuple[SdkRawGraphItem, ...] = ()
+    total: int = Field(ge=0)
+    offset: int = Field(ge=0)
+    limit: int = Field(ge=1, le=500)
+    has_more: bool = False
+    snapshot_id: str = Field(min_length=1, max_length=64)
+
+
 class SdkLayerCounts(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -2203,6 +2234,19 @@ def create_app(
     from one_memory.embedding_switch_routes import embedding_switch_router
 
     app.include_router(embedding_switch_router(protected))
+    from one_memory.live_capture import live_capture_router
+
+    def file_polled(request: Request, source_id: str) -> bool:
+        """Whether live sync reads this source's own files, so the hook's copy is redundant."""
+        registration = getattr(request.app.state, "source_catalog", {}).get(source_id)
+        return (
+            runtime_settings.live_sync_enabled
+            and registration is not None
+            and registration.capabilities.live_sync is CapabilityState.IMPLEMENTED
+        )
+
+    # Host hooks hand their turn over here instead of opening the database.
+    app.include_router(live_capture_router(protected, file_polled=file_polled))
 
     app.add_middleware(
         CORSMiddleware,
@@ -4480,6 +4524,164 @@ def create_app(
         ],
     ] = {}
     raw_turn_cache_locks: dict[tuple[object, ...], asyncio.Lock] = {}
+    raw_graph_cache: dict[
+        tuple[object, ...],
+        tuple[
+            float,
+            int,
+            tuple[tuple[str, str | None], ...],
+            tuple[SdkRawGraphItem, ...],
+            int,
+        ],
+    ] = {}
+    raw_graph_cache_locks: dict[tuple[object, ...], asyncio.Lock] = {}
+    raw_graph_snapshots: dict[
+        str,
+        tuple[float, tuple[object, ...], tuple[SdkRawGraphItem, ...], int],
+    ] = {}
+    raw_graph_cache_ttl = 300.0
+    raw_graph_snapshot_ttl = 120.0
+    raw_graph_cache_budget = 8 * 1024 * 1024
+
+    def graph_cache_size(items: Iterable[SdkRawGraphItem]) -> int:
+        return sum(
+            128
+            + len(item.turn_id.encode())
+            + len(item.raw_id.encode())
+            + len(item.label.encode())
+            + len(item.source.encode())
+            + len(item.session_id.encode())
+            for item in items
+        )
+
+    def prune_raw_graph_state() -> None:
+        now = time.monotonic()
+        for key, cached in tuple(raw_graph_cache.items()):
+            if now - cached[0] > raw_graph_cache_ttl:
+                raw_graph_cache.pop(key, None)
+        for snapshot_id, snapshot in tuple(raw_graph_snapshots.items()):
+            if now - snapshot[0] > raw_graph_snapshot_ttl:
+                raw_graph_snapshots.pop(snapshot_id, None)
+        while raw_graph_cache and (
+            len(raw_graph_cache) > 8
+            or sum(cached[4] for cached in raw_graph_cache.values()) > raw_graph_cache_budget
+        ):
+            raw_graph_cache.pop(next(iter(raw_graph_cache)))
+        while raw_graph_snapshots and (
+            len(raw_graph_snapshots) > 8
+            or sum(snapshot[3] for snapshot in raw_graph_snapshots.values())
+            > raw_graph_cache_budget
+        ):
+            raw_graph_snapshots.pop(next(iter(raw_graph_snapshots)))
+
+    def graph_items(
+        records: Iterable[HySdkRawRecord],
+    ) -> tuple[SdkRawGraphItem, ...]:
+        items: list[SdkRawGraphItem] = []
+        for record in records:
+            for turn in reversed(raw_display_turns(record)):
+                label = re.sub(r"\s+", " ", turn.content).strip()[:240]
+                items.append(
+                    SdkRawGraphItem(
+                        turn_id=turn.turn_id,
+                        raw_id=record.raw_id,
+                        label=label or record.raw_id,
+                        source=record.source,
+                        session_id=record.session_id,
+                        memory_at=record.memory_at,
+                        gmt_created=record.gmt_created,
+                    )
+                )
+        return tuple(items)
+
+    async def raw_graph_catalog(
+        client: object,
+        *,
+        query: dict[str, object],
+        cache_key: tuple[object, ...],
+    ) -> tuple[SdkRawGraphItem, ...]:
+        """Build a complete raw-turn map without retaining raw bodies.
+
+        The SDK remains the sole raw authority. This cache contains only stable
+        ids and short labels and can be dropped at any time. A verified first
+        page makes one catalog snapshot atomic from the reader's perspective.
+        """
+        prune_raw_graph_state()
+        if len(raw_graph_cache_locks) > 16:
+            for stale_key, stale_lock in tuple(raw_graph_cache_locks.items()):
+                if stale_key not in raw_graph_cache and not stale_lock.locked():
+                    raw_graph_cache_locks.pop(stale_key, None)
+        lock = raw_graph_cache_locks.setdefault(cache_key, asyncio.Lock())
+        async with lock:
+            for _attempt in range(3):
+                value = await asyncio.to_thread(
+                    client.list_memories,
+                    **query,
+                    offset=0,
+                    limit=500,
+                )
+                first_page = HySdkRawPage.from_memory_list(value, limit=500, offset=0)
+                signature = tuple((record.raw_id, record.status) for record in first_page.raw)
+                cached = raw_graph_cache.get(cache_key)
+                if cached is not None and cached[1] == first_page.total and cached[2] == signature:
+                    return cached[3]
+                added = (
+                    None
+                    if cached is None
+                    else raw_prefix_added(
+                        cached[2],
+                        signature,
+                        cached[1],
+                        first_page.total,
+                    )
+                )
+                if cached is not None and added is not None:
+                    items = graph_items(first_page.raw[:added]) + cached[3]
+                else:
+                    items = graph_items(first_page.raw)
+                    raw_offset = len(first_page.raw)
+                    snapshot_changed = False
+                    while first_page.raw and raw_offset < first_page.total:
+                        value = await asyncio.to_thread(
+                            client.list_memories,
+                            **query,
+                            offset=raw_offset,
+                            limit=500,
+                        )
+                        page = HySdkRawPage.from_memory_list(value, limit=500, offset=raw_offset)
+                        if (
+                            page.total != first_page.total
+                            or not page.raw
+                            or raw_offset + len(page.raw) > first_page.total
+                        ):
+                            snapshot_changed = True
+                            break
+                        items += graph_items(page.raw)
+                        raw_offset += len(page.raw)
+                    if snapshot_changed or raw_offset != first_page.total:
+                        continue
+
+                verify_value = await asyncio.to_thread(
+                    client.list_memories,
+                    **query,
+                    offset=0,
+                    limit=500,
+                )
+                verify = HySdkRawPage.from_memory_list(verify_value, limit=500, offset=0)
+                verify_signature = tuple((record.raw_id, record.status) for record in verify.raw)
+                if verify.total != first_page.total or verify_signature != signature:
+                    continue
+                raw_graph_cache.pop(cache_key, None)
+                raw_graph_cache[cache_key] = (
+                    time.monotonic(),
+                    first_page.total,
+                    signature,
+                    items,
+                    graph_cache_size(items),
+                )
+                prune_raw_graph_state()
+                return items
+        raise RuntimeError("hy_memory_raw_snapshot_busy")
 
     @app.get(
         "/api/v2/raw",
@@ -4491,6 +4693,8 @@ def create_app(
         offset: int = Query(default=0, ge=0),
         limit: int = Query(default=100, ge=1, le=500),
         unit: Literal["raw", "turn"] = Query(default="raw"),
+        paging: Literal["offset", "cursor"] = Query(default="offset"),
+        cursor: str | None = Query(default=None, max_length=160),
         user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
         exclude_sources: list[str] | None = Query(default=None),  # noqa: B008
         session_id: list[str] | None = Query(default=None),  # noqa: B008
@@ -4516,9 +4720,52 @@ def create_app(
             _library_values(statuses or [], MEMORY_STATUSES, "memory_status_unknown")
             or raw_list_filters()["statuses"]
         )
+        if paging == "cursor" and unit != "turn":
+            raise HTTPException(status_code=422, detail="raw_cursor_requires_turn_unit")
+        if cursor is not None and paging != "cursor":
+            raise HTTPException(status_code=422, detail="raw_cursor_requires_cursor_paging")
+        if paging == "cursor" and (offset or after is not None or before is not None):
+            raise HTTPException(status_code=422, detail="raw_cursor_filter_unsupported")
+        raw_cursor = (0, 0, 0, 0, "", "")
+        if cursor:
+            parts = cursor.split(":")
+            if (
+                len(parts) != 7
+                or parts[0] != "turn"
+                or any(re.fullmatch(r"[0-9]+", part) is None for part in parts[1:5])
+                or re.fullmatch(r"(?:p?[0-9a-f]{16})?", parts[5]) is None
+                or re.fullmatch(r"[0-9a-f]{16}", parts[6]) is None
+            ):
+                raise HTTPException(status_code=422, detail="raw_cursor_invalid")
+            raw_cursor = (
+                int(parts[1]),
+                int(parts[2]),
+                int(parts[3]),
+                int(parts[4]),
+                parts[5],
+                parts[6],
+            )
+            if any(value > 100_000_000 for value in raw_cursor[:4]):
+                raise HTTPException(status_code=422, detail="raw_cursor_invalid")
         sources = split_csv(source)
         excluded = split_csv(exclude_sources)
         sessions = split_csv(session_id)
+        cursor_scope = hashlib.sha256(
+            json.dumps(
+                {
+                    "user_id": user_id,
+                    "statuses": sorted(chosen_statuses),
+                    "sources": sorted(sources),
+                    "excluded": sorted(excluded),
+                    "sessions": sorted(sessions),
+                    "order": order,
+                },
+                sort_keys=True,
+                separators=(",", ":"),
+            ).encode()
+        ).hexdigest()[:16]
+        if cursor and raw_cursor[5] != cursor_scope:
+            raise HTTPException(status_code=422, detail="raw_cursor_scope_mismatch")
         try:
             client = await _sdk_client_handle(app).client()
             query = {
@@ -4527,8 +4774,138 @@ def create_app(
                 "include_sources": sources or None,
                 "exclude_sources": excluded or None,
                 "session_ids": sessions or None,
-                "order": order if unit == "raw" else "desc",
+                "order": order if unit == "raw" or paging == "cursor" else "desc",
             }
+            if unit == "turn" and paging == "cursor":
+                (
+                    raw_offset,
+                    turn_offset,
+                    emitted,
+                    previous_total,
+                    expected_raw,
+                    _scope,
+                ) = raw_cursor
+                value = await asyncio.to_thread(
+                    client.list_memories,
+                    **query,
+                    offset=raw_offset,
+                    limit=min(limit + 1, 500),
+                )
+                raw_page = HySdkRawPage.from_memory_list(
+                    value, limit=min(limit + 1, 500), offset=raw_offset
+                )
+
+                def raw_anchor(record: HySdkRawRecord) -> str:
+                    return hashlib.sha256(
+                        f"{record.raw_id}\0{record.content}".encode()
+                    ).hexdigest()[:16]
+
+                if cursor:
+                    if raw_page.total < previous_total:
+                        raise HTTPException(status_code=409, detail="raw_cursor_stale")
+                    observed_total = raw_page.total
+                    added = raw_page.total - previous_total
+                    if added and order == "desc":
+                        raw_offset += added
+                        value = await asyncio.to_thread(
+                            client.list_memories,
+                            **query,
+                            offset=raw_offset,
+                            limit=min(limit + 1, 500),
+                        )
+                        raw_page = HySdkRawPage.from_memory_list(
+                            value,
+                            limit=min(limit + 1, 500),
+                            offset=raw_offset,
+                        )
+                        if raw_page.total != observed_total:
+                            raise HTTPException(status_code=409, detail="raw_cursor_stale")
+
+                    if expected_raw.startswith("p"):
+                        if raw_offset == 0:
+                            raise HTTPException(status_code=409, detail="raw_cursor_stale")
+                        previous_value = await asyncio.to_thread(
+                            client.list_memories,
+                            **query,
+                            offset=raw_offset - 1,
+                            limit=1,
+                        )
+                        previous_page = HySdkRawPage.from_memory_list(
+                            previous_value, limit=1, offset=raw_offset - 1
+                        )
+                        valid_anchor = (
+                            previous_page.total == raw_page.total
+                            and bool(previous_page.raw)
+                            and raw_anchor(previous_page.raw[0]) == expected_raw[1:]
+                        )
+                    else:
+                        valid_anchor = (
+                            bool(raw_page.raw) and raw_anchor(raw_page.raw[0]) == expected_raw
+                        )
+                    if expected_raw and not valid_anchor:
+                        raise HTTPException(status_code=409, detail="raw_cursor_stale")
+                selected_turns: list[tuple[HySdkRawRecord, RawDisplayTurn]] = []
+                next_cursor: str | None = None
+                for record_index, record in enumerate(raw_page.raw):
+                    turns = raw_display_turns(record)
+                    ordered_turns = tuple(reversed(turns)) if order == "desc" else turns
+                    start = turn_offset if record_index == 0 else 0
+                    for index in range(start, len(ordered_turns)):
+                        selected_turns.append((record, ordered_turns[index]))
+                        if len(selected_turns) < limit:
+                            continue
+                        absolute_raw = raw_offset + record_index
+                        next_raw = absolute_raw
+                        next_turn = index + 1
+                        if next_turn >= len(ordered_turns):
+                            next_raw += 1
+                            next_turn = 0
+                        if next_raw < raw_page.total:
+                            if next_turn:
+                                anchor_record = record
+                            else:
+                                next_index = record_index + 1
+                                anchor_record = (
+                                    raw_page.raw[next_index]
+                                    if next_index < len(raw_page.raw)
+                                    else None
+                                )
+                            anchor = (
+                                raw_anchor(anchor_record)
+                                if anchor_record is not None
+                                else f"p{raw_anchor(record)}"
+                            )
+                            next_cursor = (
+                                f"turn:{next_raw}:{next_turn}:"
+                                f"{emitted + len(selected_turns)}:{raw_page.total}:"
+                                f"{anchor}:{cursor_scope}"
+                            )
+                        break
+                    if len(selected_turns) >= limit:
+                        break
+                if next_cursor is None and raw_offset + len(raw_page.raw) < raw_page.total:
+                    if not raw_page.raw:
+                        raise HTTPException(status_code=409, detail="raw_cursor_stale")
+                    next_raw = raw_offset + len(raw_page.raw)
+                    previous_anchor = raw_anchor(raw_page.raw[-1])
+                    next_cursor = (
+                        f"turn:{next_raw}:0:{emitted + len(selected_turns)}:"
+                        f"{raw_page.total}:p{previous_anchor}:{cursor_scope}"
+                    )
+                return SdkRawPage(
+                    user_id=user_id,
+                    items=tuple(SdkRawItem.of(record, turn) for record, turn in selected_turns),
+                    # Cursor consumers do not use a precise total. This lower
+                    # bound preserves the legacy numeric field without forcing
+                    # a full scan merely to count variable-size turn batches.
+                    total=emitted + len(selected_turns) + (1 if next_cursor else 0),
+                    offset=emitted,
+                    limit=limit,
+                    unit="turn",
+                    next_cursor=next_cursor,
+                    has_more=next_cursor is not None,
+                    total_exact=False,
+                )
             if unit == "raw":
                 value = await asyncio.to_thread(
                     client.list_memories,
@@ -4691,6 +5068,114 @@ def create_app(
             time_filtered=time_filtered,
         )
 
+    @app.get(
+        "/api/v2/raw/graph",
+        response_model=SdkRawGraphPage,
+        dependencies=strict,
+    )
+    async def sdk_raw_graph(
+        source: list[str] | None = Query(default=None),  # noqa: B008
+        offset: int = Query(default=0, ge=0),
+        limit: int = Query(default=500, ge=1, le=500),
+        snapshot_id: str | None = Query(default=None, max_length=64),
+        user_id: str = Query(default=DEFAULT_USER_ID, pattern=USER_ID_PATTERN),
+        exclude_sources: list[str] | None = Query(default=None),  # noqa: B008
+        session_id: list[str] | None = Query(default=None),  # noqa: B008
+        statuses: list[str] | None = Query(default=None),  # noqa: B008
+    ) -> SdkRawGraphPage:
+        """Complete lightweight raw graph, independent of list pagination."""
+        chosen_statuses = (
+            _library_values(
+                statuses or [],
+                MEMORY_STATUSES,
+                "memory_status_unknown",
+            )
+            or raw_list_filters()["statuses"]
+        )
+        sources = split_csv(source)
+        excluded = split_csv(exclude_sources)
+        sessions = split_csv(session_id)
+        snapshot_scope: tuple[object, ...] = (
+            user_id,
+            tuple(sorted(chosen_statuses)),
+            tuple(sorted(sources)),
+            tuple(sorted(excluded)),
+            tuple(sorted(sessions)),
+        )
+        if offset and snapshot_id is None:
+            raise HTTPException(
+                status_code=422,
+                detail="raw_graph_snapshot_required",
+            )
+        prune_raw_graph_state()
+        if snapshot_id is not None:
+            snapshot = raw_graph_snapshots.get(snapshot_id)
+            if snapshot is None or snapshot[1] != snapshot_scope:
+                raise HTTPException(
+                    status_code=409,
+                    detail="raw_graph_snapshot_stale",
+                )
+            items = snapshot[2]
+        else:
+            query: dict[str, object] = {
+                "user_id": user_id,
+                **raw_list_filters(chosen_statuses),
+                "order": "desc",
+            }
+            cache_key: tuple[object, ...] = (
+                user_id,
+                tuple(sorted(chosen_statuses)),
+            )
+            try:
+                client = await _sdk_client_handle(app).client()
+                catalog = await raw_graph_catalog(
+                    client,
+                    query=query,
+                    cache_key=cache_key,
+                )
+            except HTTPException:
+                raise
+            except Exception as error:
+                raise _sdk_http_error(
+                    error,
+                    "hy_memory_raw_graph_failed",
+                ) from None
+            source_set = set(sources)
+            excluded_set = set(excluded)
+            session_set = set(sessions)
+            items = tuple(
+                item
+                for item in catalog
+                if (not source_set or item.source in source_set)
+                and item.source not in excluded_set
+                and (not session_set or item.session_id in session_set)
+            )
+            snapshot_id = uuid4().hex
+            raw_graph_snapshots[snapshot_id] = (
+                time.monotonic(),
+                snapshot_scope,
+                items,
+                graph_cache_size(items),
+            )
+            prune_raw_graph_state()
+            if snapshot_id not in raw_graph_snapshots:
+                raise HTTPException(
+                    status_code=413,
+                    detail="raw_graph_snapshot_too_large",
+                )
+        if snapshot_id is None:
+            raise RuntimeError("raw_graph_snapshot_missing")
+        selected = items[offset : offset + limit]
+        return SdkRawGraphPage(
+            user_id=user_id,
+            items=selected,
+            total=len(items),
+            offset=offset,
+            limit=limit,
+            has_more=offset + len(selected) < len(items),
+            snapshot_id=snapshot_id,
+        )
+
     @app.post(
         "/api/v2/memories/ask",
         response_model=SdkMemoryAnswer,

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

@@ -0,0 +1,133 @@
+"""The hook side of live capture: hand the turn to the running Core, nothing more.
+
+A host runs `one-memory capture <source>` as a short-lived process on every
+hook, often several at once. That process used to open the main database
+itself and write Evidence and the write queue from outside Core's single
+writer. It now never opens the database: it reads the hook's JSON, posts it to
+the running Core over loopback with the runtime token, and exits. Core applies
+every gate and stages the turn in-process (`live_capture.capture_hook`).
+
+Anything that goes wrong — Core not running, a stale receipt, a slow answer —
+drops the turn silently. There is no local fallback write: file-backed sources
+are read again by live sync from their persisted cursor once Core is back.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import TextIO
+
+CAPTURE_SOURCES = frozenset(
+    {
+        "workbuddy",
+        "claude-code",
+        "codex",
+        "cursor",
+        "pi",
+        "qwen-code",
+        "qwenwork",
+        "hermes",
+        "deepseek-harness",
+        "opencode",
+        "openclaw",
+    }
+)
+SDK_MIGRATION_CAPTURE_FENCE = ".sdk-migration-capture-fence.json"
+#: Core's in-process intake for a hook's payload; see `live_capture`.
+CAPTURE_ROUTE = "/api/v1/live-capture/{source_id}"
+#: Whole request, connect to answer. Pi and OpenCode wait for the hook
+#: synchronously (3 s, interpreter start included), so this stays well under.
+HANDOFF_TIMEOUT_SECONDS = 1.5
+#: A hook carries one turn, or one session's visible text at most.
+MAX_PAYLOAD_BYTES = 8 * 1024 * 1024
+
+
+def data_directory() -> Path:
+    from one_memory.config import load_settings
+
+    return load_settings().data_dir
+
+
+def capture_stdio(source_id: str, stdin: TextIO, output: TextIO) -> int:
+    """Host hooks must stay silent. A bad payload or an absent Core does not fail the turn."""
+
+    del output
+    if source_id not in CAPTURE_SOURCES:
+        return 2
+    try:
+        data_dir = data_directory()
+        if sdk_migration_capture_fenced(data_dir):
+            return 0
+        payload = json.loads(stdin.read() or "")
+    except Exception:
+        return 0
+    if not isinstance(payload, dict):
+        return 0
+    try:
+        hand_to_core(source_id, payload, data_dir)
+    except Exception:
+        return 0
+    return 0
+
+
+def hand_to_core(
+    source_id: str,
+    payload: dict[str, object],
+    data_dir: Path,
+    *,
+    timeout: float = HANDOFF_TIMEOUT_SECONDS,
+) -> bool:
+    """Post the payload to the Core named by this home's receipt. True when Core took it.
+
+    Only the receipt, the runtime token and a loopback socket are touched; the
+    main database is never opened from here.
+    """
+    from one_memory.runtime_client import core_endpoint
+
+    endpoint = core_endpoint(data_dir)
+    if endpoint is None:
+        return False
+    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    if len(body) > MAX_PAYLOAD_BYTES:
+        return False
+    from one_memory.http_client import create_client
+
+    with create_client(timeout=timeout) as client:
+        response = client.post(
+            f"http://{endpoint.host}:{endpoint.port}{CAPTURE_ROUTE.format(source_id=source_id)}",
+            content=body,
+            headers={
+                "Authorization": f"Bearer {endpoint.token}",
+                "Content-Type": "application/json",
+            },
+        )
+    return response.status_code == 202
+
+
+def sdk_migration_capture_fenced(data_dir: Path) -> bool:
+    """Ignore stale fences; a live migration or a failed one pauses hook writes.
+
+    A failed upgrade migration leaves the fence `frozen` (no pid): the home was
+    put back as it was before the upgrade and takes no writes until the next
+    migration attempt, which replaces the fence and lifts it on success.
+    """
+    marker = data_dir / SDK_MIGRATION_CAPTURE_FENCE
+    try:
+        document = json.loads(marker.read_text(encoding="utf-8"))
+        if isinstance(document, dict) and document.get("frozen") is True:
+            return True
+        pid = int(document["pid"])
+        if pid < 1:
+            raise ValueError("invalid migration fence pid")
+        os.kill(pid, 0)
+        return True
+    except FileNotFoundError:
+        return False
+    except ProcessLookupError:
+        marker.unlink(missing_ok=True)
+        return False
+    except PermissionError:
+        return True
+    except (KeyError, TypeError, ValueError, json.JSONDecodeError, OSError):
+        marker.unlink(missing_ok=True)
+        return False

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

@@ -119,7 +119,7 @@ def run(arguments: Sequence[str], *, output: TextIO | None = None) -> int:
     if command == "sdk-migration-status":
         return sdk_migration_status(options, stream)
     if command == "capture" and len(options) == 1:
-        from one_memory.live_capture import capture_stdio
+        from one_memory.capture_handoff import capture_stdio
 
         return capture_stdio(options[0], sys.stdin, stream)
     if command not in {"status", "doctor"} or options not in ([], ["--json"]):

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

@@ -1,6 +1,6 @@
 import hashlib
 import os
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncIterator, Callable, Iterator
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -28,6 +28,7 @@ def discovered_off_loop(
     suffixes: frozenset[str],
     max_targets: int,
     excluded_directory_names: frozenset[str] = frozenset(),
+    directory_predicate: Callable[[Path], bool] | None = None,
 ) -> AsyncIterator[SourceFileDiscoveryEvent]:
     """The same walk, for callers that have an event loop to keep free.
 
@@ -43,6 +44,7 @@ def discovered_off_loop(
             suffixes=suffixes,
             max_targets=max_targets,
             excluded_directory_names=excluded_directory_names,
+            directory_predicate=directory_predicate,
         ),
         scope_key=grant.source_id,
     )
@@ -54,6 +56,7 @@ def discover_source_files(
     suffixes: frozenset[str],
     max_targets: int,
     excluded_directory_names: frozenset[str] = frozenset(),
+    directory_predicate: Callable[[Path], bool] | None = None,
 ) -> Iterator[SourceFileDiscoveryEvent]:
     """Metadata only: one lstat per candidate, no open and no per-file grant lookup.
 
@@ -71,10 +74,16 @@ def discover_source_files(
         grant.root,
         followlinks=False,
     ):
+        current = Path(directory)
         child_directories[:] = sorted(
             child
             for child in child_directories
-            if not (Path(directory) / child).is_symlink() and child not in excluded_directory_names
+            if not (current / child).is_symlink()
+            and child not in excluded_directory_names
+            and (
+                directory_predicate is None
+                or directory_predicate((current / child).relative_to(grant.root))
+            )
         )
         for filename in sorted(filenames):
             if Path(filename).suffix.lower() not in suffixes:

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

@@ -591,7 +591,11 @@ class PollingLiveSyncSupervisor:
 
     async def _poll_source(self, source_id: str) -> None:
         while True:
-            await asyncio.sleep(self.interval_seconds)
+            # A watched source is normally triggered by its filesystem event.
+            # Its timer is only a missed-event backstop; recursively walking
+            # every multi-gigabyte host root once a minute starved unrelated
+            # Core reads even when no source had changed.
+            await asyncio.sleep(self._poll_interval(source_id))
             try:
                 await self.trigger(source_id)
             except asyncio.CancelledError:
@@ -608,6 +612,11 @@ class PollingLiveSyncSupervisor:
                 except Exception as again:
                     self._note_internal_error(source_id, again)
 
+    def _poll_interval(self, source_id: str) -> float:
+        if source_id in (self._watched_sources or ()):
+            return max(self.interval_seconds, 15 * 60)
+        return self.interval_seconds
+
     def _note_worker_still_running(self, source_id: str) -> None:
         current = self.health(source_id)
         self._set_health(

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

@@ -226,6 +226,9 @@ class JsonlSourceAdapter:
         self.header_gate = header_gate
         self._header_cache: dict[str, tuple[str, dict[str, JsonValue] | None]] = {}
         self._history_listing_cache: SourceListing | None = None
+        self._probe_listing_cache: tuple[
+            dict[str, SourceCursor], int | None, SourceListing
+        ] | None = None
 
     @property
     def descriptor(self) -> SourceDescriptor:
@@ -281,6 +284,11 @@ class JsonlSourceAdapter:
             predicate=self.file_predicate,
             cursors=options.cursors,
         )
+        self._probe_listing_cache = (
+            dict(options.cursors),
+            options.max_scan_targets,
+            listing,
+        )
         return bool(listing.changed or listing.failures)
 
     async def live_baseline(self) -> dict[str, SourceCursor]:
@@ -315,9 +323,11 @@ class JsonlSourceAdapter:
             async for event in self._scan_frozen(options):
                 yield event
             return
-        listing = await asyncio.to_thread(
-            self._history_listing if options.reuse_listing else self._fresh_listing,
-            options,
+        listing = (
+            await asyncio.to_thread(self._history_listing, options)
+            if options.reuse_listing
+            else self._take_probe_listing(options)
+            or await asyncio.to_thread(self._fresh_listing, options)
         )
         for failure in listing.failures:
             yield ScanFailure(reason_code=discovery_failure_code(failure))
@@ -349,6 +359,16 @@ class JsonlSourceAdapter:
             self._history_listing_cache = listing
         return listing
 
+    def _take_probe_listing(self, options: ScanOptions) -> "SourceListing | None":
+        cached = self._probe_listing_cache
+        self._probe_listing_cache = None
+        if cached is None:
+            return None
+        cursors, max_scan_targets, listing = cached
+        if cursors != options.cursors or max_scan_targets != options.max_scan_targets:
+            return None
+        return listing
+
     def _fresh_listing(self, options: ScanOptions) -> "SourceListing":
         return list_changed_files(
             self.grant,

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

@@ -9,6 +9,7 @@ from collections.abc import AsyncIterator, Iterator
 from dataclasses import dataclass, replace
 from datetime import UTC, datetime, timedelta, timezone
 from functools import partial
+from pathlib import Path
 
 from pydantic import JsonValue
 
@@ -175,6 +176,9 @@ class CursorUnifiedSourceAdapter:
         self.grant = grant
         self.source_version = source_version
         self._history_listing_cache: _CursorListing | None = None
+        self._probe_listing_cache: tuple[
+            dict[str, SourceCursor], int | None, _CursorListing
+        ] | None = None
 
     @property
     def descriptor(self) -> SourceDescriptor:
@@ -207,6 +211,20 @@ class CursorUnifiedSourceAdapter:
         state = await self.install_state()
         return min(state.session_count, limit) if limit is not None else state.session_count
 
+    async def has_changes(self, options: ScanOptions) -> bool:
+        listing = await asyncio.to_thread(self._fresh_listing, options)
+        self._probe_listing_cache = (
+            dict(options.cursors),
+            options.max_scan_targets,
+            listing,
+        )
+        return bool(
+            listing.transcripts
+            or listing.stores
+            or listing.legacy
+            or listing.failures
+        )
+
     async def live_baseline(self) -> dict[str, SourceCursor]:
         """Capture Cursor's current tail so the realtime lane never backfills history."""
         listing = await asyncio.to_thread(
@@ -222,9 +240,11 @@ class CursorUnifiedSourceAdapter:
             async for event in self._scan_frozen(options):
                 yield event
             return
-        listing = await asyncio.to_thread(
-            self._history_listing if options.reuse_listing else self._fresh_listing,
-            options,
+        listing = (
+            await asyncio.to_thread(self._history_listing, options)
+            if options.reuse_listing
+            else self._take_probe_listing(options)
+            or await asyncio.to_thread(self._fresh_listing, options)
         )
         for failure in listing.failures:
             yield ScanFailure(reason_code=discovery_failure_code(failure))
@@ -329,6 +349,16 @@ class CursorUnifiedSourceAdapter:
             self._history_listing_cache = listing
         return listing
 
+    def _take_probe_listing(self, options: ScanOptions) -> "_CursorListing | None":
+        cached = self._probe_listing_cache
+        self._probe_listing_cache = None
+        if cached is None:
+            return None
+        cursors, max_scan_targets, listing = cached
+        if cursors != options.cursors or max_scan_targets != options.max_scan_targets:
+            return None
+        return listing
+
     def _fresh_listing(self, options: ScanOptions) -> "_CursorListing":
         return _list_cursor_files(
             self.grant,
@@ -376,6 +406,7 @@ class CursorUnifiedSourceAdapter:
             self.grant,
             suffixes=frozenset({".db"}),
             max_targets=options.max_scan_targets or 100_000,
+            directory_predicate=_cursor_data_directory,
         ):
             if isinstance(discovered, SourceFileDiscoveryFailure):
                 yield ScanFailure(reason_code=discovery_failure_code(discovered))
@@ -477,7 +508,10 @@ def _list_cursor_files(
     legacy: list[AuthorizedSourceFile] = []
     failures: list[SourceFileDiscoveryFailure] = []
     for item in discover_source_files(
-        grant, suffixes=frozenset({".jsonl", ".db", ".vscdb"}), max_targets=max_targets
+        grant,
+        suffixes=frozenset({".jsonl", ".db", ".vscdb"}),
+        max_targets=max_targets,
+        directory_predicate=_cursor_data_directory,
     ):
         if isinstance(item, SourceFileDiscoveryFailure):
             failures.append(item)
@@ -586,6 +620,25 @@ def _is_cursor_data_file(source_file: AuthorizedSourceFile) -> bool:
     )
 
 
+def _cursor_data_directory(relative_path: Path) -> bool:
+    """Enter only Cursor directories that can contain conversation authority.
+
+    The granted root also contains extensions, skills, caches, logs and agent
+    artifacts. Recursively walking all of them every live-sync poll made the
+    reader monopolize Core even though none can pass the file predicates.
+    """
+    parts = relative_path.parts
+    if not parts:
+        return False
+    if parts[0] in {"chats", "acp-sessions"}:
+        return True
+    if parts[0] == "projects":
+        return len(parts) <= 2 or parts[2] == "agent-transcripts"
+    if parts[0] == "User":
+        return len(parts) == 1 or parts[1] in {"globalStorage", "workspaceStorage"}
+    return False
+
+
 def _is_transcript_file(source_file: AuthorizedSourceFile) -> bool:
     parts = source_file.relative_path.parts
     return source_file.relative_path.suffix == ".jsonl" and "agent-transcripts" in parts
@@ -634,6 +687,7 @@ def _select_transcript_files(
         grant,
         suffixes=frozenset({".jsonl"}),
         max_targets=100_000,
+        directory_predicate=_cursor_data_directory,
     ):
         if not isinstance(item, AuthorizedSourceFile) or not _is_transcript_file(item):
             continue
@@ -654,6 +708,7 @@ def _subagent_conversation_ids(grant: AuthorizedSourceRoot) -> set[str]:
             grant,
             suffixes=frozenset({".jsonl"}),
             max_targets=100_000,
+            directory_predicate=_cursor_data_directory,
         )
         if isinstance(item, AuthorizedSourceFile)
         and _is_transcript_file(item)

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

@@ -1,15 +1,35 @@
-"""Write visible hook text into Evidence. Tool output stays out."""
+"""Core's intake for host hooks: visible text only, staged under Core's writer.
 
+The hook process (`capture_handoff`) never opens the database; it posts the
+hook's JSON to `POST /api/v1/live-capture/{source}` on the running Core, which
+calls `capture_hook` here. Tool output stays out.
+
+A source that live sync already reads from its own files is left to that
+path: the hook and the file name the same message differently (the hook has
+no workspace and often no message id), so staging both sent one turn to the
+SDK twice. Only a source no file poller follows is staged from the hook.
+"""
+
+import asyncio
 import json
-import os
 import time
+from collections.abc import Callable
 from datetime import UTC, datetime
 from enum import StrEnum
 from pathlib import Path
-from typing import TextIO, cast
+from typing import cast
 
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.params import Depends
 from pydantic import JsonValue
 
+from one_memory.capture_handoff import (
+    CAPTURE_ROUTE,
+    CAPTURE_SOURCES,
+    MAX_PAYLOAD_BYTES,
+    SDK_MIGRATION_CAPTURE_FENCE,
+    sdk_migration_capture_fenced,
+)
 from one_memory.database_access import main_database
 from one_memory.derived_echo import PREFACE, strip_injected_memory
 from one_memory.imports.access import opaque_workspace_id, safe_project_label
@@ -19,6 +39,7 @@ from one_memory.imports.models import (
     EvidenceRecord,
     OriginMetadata,
     WrittenBy,
+    materialize_write_input,
 )
 from one_memory.imports.sources.claude_code import parse_claude_code_record
 from one_memory.imports.sources.codex import HARNESS_PREFIXES, parse_codex_record
@@ -38,23 +59,21 @@ from one_memory.imports.sources.parsing import (
 )
 from one_memory.imports.sources.pi import _is_automated_session
 from one_memory.imports.sources.workbuddy import _is_scheduled_automation, parse_workbuddy_record
-from one_memory.imports.storage import EvidenceStore
+from one_memory.memory_server.durable_queue import DurableWriteQueue
+from one_memory.sdk_data_plane_migration import MemoryAuthority
+
+__all__ = [
+    "CAPTURE_SOURCES",
+    "SDK_MIGRATION_CAPTURE_FENCE",
+    "CaptureOutcome",
+    "CaptureRejection",
+    "capture_hook",
+    "capture_rejection",
+    "live_capture_router",
+    "record_capture_rejection",
+    "sdk_migration_capture_fenced",
+]
 
-CAPTURE_SOURCES = frozenset(
-    {
-        "workbuddy",
-        "claude-code",
-        "codex",
-        "cursor",
-        "pi",
-        "qwen-code",
-        "qwenwork",
-        "hermes",
-        "deepseek-harness",
-        "opencode",
-        "openclaw",
-    }
-)
 _UNKNOWN_USER = frozenset({"hermes", "opencode", "openclaw"})
 _USER_FIELDS = {
     "UserPromptSubmit": "prompt",
@@ -75,112 +94,130 @@ _FILE_FALLBACK = {
 }
 _FALLBACK_EVENTS = frozenset({"Stop", "stop", "SubagentStop", "StopFailure"})
 _TEXT_BLOCKS = frozenset({"text"})
-SDK_MIGRATION_CAPTURE_FENCE = ".sdk-migration-capture-fence.json"
 
 
-def database_path() -> Path:
-    from one_memory.config import load_settings
+class CaptureOutcome(StrEnum):
+    """What Core did with one hook payload. Never the payload itself."""
 
-    return load_settings().data_dir / "one-memory.sqlite3"
+    STAGED = "staged"
+    #: Live sync reads this source's own files; that path owns the turn.
+    FILE_POLLED = "file_polled"
+    REJECTED = "rejected"
+    IGNORED = "ignored"
 
 
-def capture_stdio(source_id: str, stdin: TextIO, output: TextIO) -> int:
-    """Host hooks must stay silent. A bad payload does not fail the turn."""
+def capture_hook(
+    source_id: str,
+    payload: object,
+    database: Path,
+    *,
+    queue: DurableWriteQueue,
+    file_polled: Callable[[str], bool] = lambda _source_id: False,
+) -> CaptureOutcome:
+    """Gate one hook payload and stage its visible lines, inside Core.
 
-    del output
-    if source_id not in CAPTURE_SOURCES:
-        return 2
-    database = database_path()
-    if sdk_migration_capture_fenced(database.parent):
-        return 0
-    try:
-        payload = json.loads(stdin.read() or "")
-    except json.JSONDecodeError:
-        return 0
-    try:
-        capture_hook(source_id, payload, database)
-    except Exception:
-        return 0
-    return 0
-
-
-def sdk_migration_capture_fenced(data_dir: Path) -> bool:
-    """Ignore stale fences; a live migration or a failed one pauses hook writes.
-
-    A failed upgrade migration leaves the fence `frozen` (no pid): the home was
-    put back as it was before the upgrade and takes no writes until the next
-    migration attempt, which replaces the fence and lifts it on success.
+    Runs on SDK authority through Core's single writer: the lines become
+    write-job input exactly as live file sync stages them
+    (`materialize_write_input` -> `stage_sdk_input` -> `finalize_sdk_file`,
+    live priority). No Evidence table is involved.
     """
-    marker = data_dir / SDK_MIGRATION_CAPTURE_FENCE
-    try:
-        document = json.loads(marker.read_text(encoding="utf-8"))
-        if isinstance(document, dict) and document.get("frozen") is True:
-            return True
-        pid = int(document["pid"])
-        if pid < 1:
-            raise ValueError("invalid migration fence pid")
-        os.kill(pid, 0)
-        return True
-    except FileNotFoundError:
-        return False
-    except ProcessLookupError:
-        marker.unlink(missing_ok=True)
-        return False
-    except PermissionError:
-        return True
-    except (KeyError, TypeError, ValueError, json.JSONDecodeError, OSError):
-        marker.unlink(missing_ok=True)
-        return False
-
-
-def capture_hook(source_id: str, payload: object, database: Path) -> bool:
     if source_id not in CAPTURE_SOURCES or not isinstance(payload, dict):
-        return False
+        return CaptureOutcome.IGNORED
     # Cursor also runs ~/.claude/settings.json hooks; its own hook already files the turn.
     if source_id != "cursor" and "cursor_version" in payload:
-        return False
+        return CaptureOutcome.IGNORED
     if not database.is_file():
-        return False
+        return CaptureOutcome.IGNORED
     rejection = capture_rejection(database, source_id)
     if rejection is not None:
         # Silent, and the reason is counted rather than printed: a hook that
         # spoke would put this into the host's turn as text.
         record_capture_rejection(database, source_id, rejection)
-        return False
+        return CaptureOutcome.REJECTED
     if source_id == "pi" and _is_automated_session(first_string(payload.get("cwd"))):
-        return False
-    lines = _messages(source_id, payload)
-    if lines:
-        conversation_id = _conversation(payload)
-        store = EvidenceStore(database)
-        wrote = False
-        for role, written_by, verbatim, message_id in lines:
-            target = conversation_id
-            if target is None:
-                continue
-            result = store.put(
-                EvidenceInput(
-                    source_id=source_id,
-                    conversation_id=target,
-                    message_id=message_id,
-                    source_ordinal=None if message_id else "hook-visible",
-                    role=role,
-                    written_by=written_by,
-                    created_at=datetime.now(UTC),
-                    verbatim=verbatim,
-                    origin_meta={EvidenceOrigin.HOOK: OriginMetadata()},
-                )
-            )
-            _submit_live_memory(
-                store, result.record, changed=result.was_created or result.was_revised
-            )
-            wrote = True
-        return wrote
-    return _capture_transcript(source_id, payload, database)
+        return CaptureOutcome.IGNORED
+    if file_polled(source_id):
+        # The same turn reaches the SDK once, from the file: the two lanes give
+        # one message different identities, so staging both wrote it twice.
+        return CaptureOutcome.FILE_POLLED
+    inputs = _hook_inputs(source_id, payload) or _capture_transcript(source_id, payload, database)
+    if not inputs:
+        return CaptureOutcome.IGNORED
+    observed = datetime.now(UTC)
+    conversations: dict[str, list[EvidenceRecord]] = {}
+    for value in inputs:
+        conversations.setdefault(value.conversation_id, []).append(
+            materialize_write_input(value, observed_at=observed)
+        )
+    for conversation_id, records in conversations.items():
+        # The turn rule decides what is written (`turn_batches`): a turn is
+        # complete when the next user message arrives, batches are 5 turns or
+        # 8000 characters, and Core writes the rest after 10 quiet minutes.
+        queue.assemble_live_records(tuple(records), file_key=f"hook:{conversation_id}")
+    return CaptureOutcome.STAGED
 
 
-def _sync_open(database: Path, source_id: str) -> bool:
-    return capture_rejection(database, source_id) is None
+def _hook_inputs(source_id: str, payload: dict[str, object]) -> list[EvidenceInput]:
+    conversation_id = _conversation(payload)
+    if conversation_id is None:
+        return []
+    observed = datetime.now(UTC)
+    return [
+        EvidenceInput(
+            source_id=source_id,
+            conversation_id=conversation_id,
+            message_id=message_id,
+            source_ordinal=None if message_id else "hook-visible",
+            role=role,
+            written_by=written_by,
+            created_at=observed,
+            verbatim=verbatim,
+            origin_meta={EvidenceOrigin.HOOK: OriginMetadata()},
+        )
+        for role, written_by, verbatim, message_id in _messages(source_id, payload)
+    ]
+
+
+def live_capture_router(
+    dependencies: list[Depends],
+    *,
+    file_polled: Callable[[Request, str], bool],
+) -> APIRouter:
+    """`POST /api/v1/live-capture/{source_id}`: a hook's payload, handed over by the hook.
+
+    202 whatever the gates decide, so a hook has nothing to print. The answer
+    names the outcome only, never any of the payload.
+    """
+    router = APIRouter(dependencies=dependencies)
+
+    @router.post(CAPTURE_ROUTE, status_code=202)
+    async def live_capture(source_id: str, request: Request) -> dict[str, str]:
+        if source_id not in CAPTURE_SOURCES:
+            raise HTTPException(status_code=404, detail="capture_source_not_found")
+        body = await request.body()
+        if len(body) > MAX_PAYLOAD_BYTES:
+            raise HTTPException(status_code=413, detail="capture_payload_too_large")
+        try:
+            payload = json.loads(body)
+        except (json.JSONDecodeError, UnicodeError) as error:
+            raise HTTPException(status_code=422, detail="capture_payload_invalid") from error
+        state = request.app.state
+        queue = getattr(state, "memory_write_queue", None)
+        if getattr(state, "memory_authority", None) is not MemoryAuthority.SDK or queue is None:
+            # Only an SDK-authority home is served; nothing here may bring the
+            # retired Evidence tables back for any other.
+            return {"outcome": CaptureOutcome.IGNORED.value}
+        outcome = await asyncio.to_thread(
+            capture_hook,
+            source_id,
+            payload,
+            queue.database_path,
+            queue=queue,
+            file_polled=lambda source: file_polled(request, source),
+        )
+        return {"outcome": outcome.value}
+
+    return router
 
 
 class CaptureRejection(StrEnum):
@@ -255,22 +292,6 @@ def record_capture_rejection(
         return
 
 
-def _submit_live_memory(store: EvidenceStore, record: EvidenceRecord, *, changed: bool) -> None:
-    """Add the record to its conversation's live assembling row.
-
-    The turn rule decides what is written (`turn_batches`): a turn is
-    complete when the next user message arrives, batches are 5 turns or
-    8000 characters, and Core writes the rest after 10 quiet minutes.
-    """
-    if not changed or not _sync_open(store.database_path, record.source_id):
-        return
-    from one_memory.memory_server.durable_queue import DurableWriteQueue
-
-    DurableWriteQueue(store.database_path, evidence=store).assemble_live_records(
-        (record,), file_key=f"hook:{record.conversation_id}"
-    )
-
-
 def _conversation(payload: dict[str, object]) -> str | None:
     return first_string(
         cast(JsonValue | None, payload.get("session_id")),
@@ -470,34 +491,35 @@ def _opencode_messages(
     return lines
 
 
-def _capture_transcript(source_id: str, payload: dict[str, object], database: Path) -> bool:
+def _capture_transcript(
+    source_id: str, payload: dict[str, object], database: Path
+) -> list[EvidenceInput]:
     """Stop without in-memory text reads the granted transcript, then the same parser."""
 
     event = payload.get("hook_event_name") or payload.get("hookEventName")
     parser = _FILE_FALLBACK.get(source_id)
     transcript = payload.get("transcript_path")
     if event not in _FALLBACK_EVENTS or parser is None or not isinstance(transcript, str):
-        return False
+        return []
     root = _grant_root(database, source_id)
     if root is None:
-        return False
+        return []
     try:
         granted = root.resolve()
         target = Path(transcript).resolve()
     except OSError:
-        return False
+        return []
     if target != granted and granted not in target.parents:
-        return False
+        return []
     if not target.is_file():
-        return False
+        return []
     _wait_stable(target)
     try:
         raw = target.read_text(encoding="utf-8")
     except OSError:
-        return False
+        return []
     relative = target.relative_to(granted).as_posix()
-    store = EvidenceStore(database)
-    wrote = False
+    inputs: list[EvidenceInput] = []
     for index, line in enumerate(raw.splitlines()):
         if not line.strip():
             continue
@@ -514,7 +536,7 @@ def _capture_transcript(source_id: str, payload: dict[str, object], database: Pa
         if not isinstance(parsed, ParsedMessage):
             continue
         for row_index, row in enumerate(parsed.rows()):
-            result = store.put(
+            inputs.append(
                 EvidenceInput(
                     source_id=source_id,
                     workspace=opaque_workspace_id(source_id, row.workspace),
@@ -533,11 +555,7 @@ def _capture_transcript(source_id: str, payload: dict[str, object], database: Pa
                     origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
                 )
             )
-            _submit_live_memory(
-                store, result.record, changed=result.was_created or result.was_revised
-            )
-        wrote = True
-    return wrote
+    return inputs
 
 
 def _grant_root(database: Path, source_id: str) -> Path | None:

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

@@ -26,6 +26,7 @@ if TYPE_CHECKING:
 _operation: ContextVar[tuple["ModelProbeOperations", str] | None] = ContextVar(
     "model_probe_operation", default=None
 )
+_dispatch_started: ContextVar[bool] = ContextVar("model_probe_dispatch_started", default=False)
 
 
 class ProbeCode(StrEnum):
@@ -113,16 +114,26 @@ class ModelProber:
         if existing is not None:
             return existing
         token = _operation.set((operations, request.operation_id))
+        dispatch_token = _dispatch_started.set(False)
         try:
             await self._probe(profile_id)
         except ProbeOperationConflict:
             await asyncio.to_thread(
                 operations.fail, request.operation_id, "model_probe_profile_changed"
             )
-        except Exception:
-            # Unknown dispatch/storage outcomes stay reserved, including across restart.
-            raise ProbeOperationUnavailable("model_probe_operation_unavailable") from None
+        except Exception as exc:
+            if _dispatch_started.get():
+                # Once a request may have reached the provider, preserve the
+                # reservation so a retry cannot duplicate a possibly billed call.
+                raise ProbeOperationUnavailable("model_probe_operation_unavailable") from None
+            logging.getLogger(__name__).warning(
+                "model probe failed before dispatch: %s", type(exc).__name__
+            )
+            await asyncio.to_thread(
+                operations.fail, request.operation_id, "model_probe_execution_failed"
+            )
         finally:
+            _dispatch_started.reset(dispatch_token)
             _operation.reset(token)
         return await asyncio.to_thread(operations.lookup, request.operation_id)
 
@@ -317,6 +328,8 @@ class ModelProber:
         listing_optional: bool = False,
     ) -> ProbeStage:
         await self._check_operation()
+        if _operation.get() is not None:
+            _dispatch_started.set(True)
         started = monotonic()
         try:
             response = await client.request(

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

@@ -118,7 +118,7 @@ class OnboardingState(BaseModel):
     selected_source_ids: tuple[str, ...]
     started_at: datetime | None
     completed_at: datetime | None
-    mode_intent: Literal["lite", "pro"] | None
+    mode_intent: Literal["lite", "pro", "ultra"] | None
     setup_step: Literal["review", "mode", "model"] | None
     model_profile_id: str | None
 
@@ -128,7 +128,7 @@ class OnboardingProgressUpdate(BaseModel):
 
     model_config = ConfigDict(frozen=True, extra="forbid")
 
-    mode_intent: Literal["lite", "pro"] | None = None
+    mode_intent: Literal["lite", "pro", "ultra"] | None = None
     setup_step: Literal["review", "mode", "model"] | None = None
     model_profile_id: str | None = Field(default=None, min_length=36, max_length=36)
 

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

@@ -113,6 +113,37 @@ def inspect_runtime(
     )
 
 
+@dataclass(frozen=True)
+class CoreEndpoint:
+    host: Literal["127.0.0.1"]
+    port: int
+    token: str
+
+
+def core_endpoint(
+    data_dir: Path,
+    *,
+    alive: Callable[[int], bool] = process_is_alive,
+) -> CoreEndpoint | None:
+    """Where this home's Core listens and the token it accepts, from files alone.
+
+    The receipt and token checks `inspect_runtime` makes, without its identity
+    round trip: a caller that only has to hand something over quickly lets the
+    authenticated request itself be the proof. None when no live Core is named.
+    """
+    try:
+        raw = (data_dir / "runtime.json").read_text(encoding="utf-8")
+        receipt = _receipt(json.loads(raw))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return None
+    if receipt is None or not alive(receipt.pid):
+        return None
+    token = _runtime_token(data_dir)
+    if token is None:
+        return None
+    return CoreEndpoint(host=receipt.host, port=receipt.port, token=token)
+
+
 def _receipt(value: object) -> RuntimeReceipt | None:
     if not isinstance(value, dict):
         return None

memhub/apps/core/tests/TEST_INDEX.md

@@ -138,7 +138,7 @@
 | `test_internal_preset.py` | `contract` | The optional model preset a configured build carries. |
 | `test_jsonl_snapshot_tail.py` | `contract` | Bounded EOF handling on synthetic files only, never original host history. |
 | `test_library_search_window.py` | `unit` | The library search window store and the unified record/keyword parsing. |
-| `test_live_capture.py` | `integration` | Visible hook text lands in Evidence before the transcript file is flushed. |
+| `test_live_capture.py` | `integration` | Hooks hand visible text to Core, which stages it once, without Evidence. |
 | `test_live_sync.py` | `contract` | 覆盖 live sync preempts a reader batch before it emits work、live sync cuts in front of a running history import、live sync does not resume a history import the user paused 等 24 个场景。 |
 | `test_live_sync_file_incremental.py` | `contract` | 覆盖 unchanged file metadata avoids a job and content read、changed file content is read once by the import job、workbuddy first live poll baselines history then imports only append 等 6 个场景。 |
 | `test_live_sync_job_coalescing.py` | `contract` | A poll that finds nothing must not leave an import job behind. |

memhub/apps/core/tests/measure_c1_recall_during_import.py

@@ -29,7 +29,6 @@ from one_memory.imports.sources.registry import (
     build_source_catalog,
 )
 from one_memory.imports.supervisor import ImportSupervisor
-from one_memory.live_capture import capture_hook
 
 FREEZE_THRESHOLD_SECONDS = 1.0
 
@@ -228,31 +227,17 @@ async def _run(
 
         hook_text = "realtime hook while history import is running"
         hook_started = time.monotonic()
-        result["hook_accepted"] = await asyncio.to_thread(
-            capture_hook,
-            "workbuddy",
-            {
+        # A hook hands its turn to Core over loopback; it no longer writes the
+        # database itself. What is measured is that hand-off under import load.
+        handed = await client.post(
+            "/api/v1/live-capture/workbuddy",
+            json={
                 "hook_event_name": "UserPromptSubmit",
                 "session_id": "pressure-live-session",
                 "prompt": hook_text,
             },
-            app.state.evidence_store.database_path,
         )
-        hook_deadline = hook_started + 10
-        hook_stored = False
-        while time.monotonic() < hook_deadline:
-            with sqlite3.connect(app.state.evidence_store.database_path) as connection:
-                hook_stored = (
-                    connection.execute(
-                        "SELECT 1 FROM evidence WHERE source_id='workbuddy' AND verbatim=?",
-                        (hook_text,),
-                    ).fetchone()
-                    is not None
-                )
-            if hook_stored:
-                break
-            await asyncio.sleep(0.01)
-        result["hook_stored"] = hook_stored
+        result["hook_accepted"] = handed.status_code == 202
         result["hook_visible_ms"] = round((time.monotonic() - hook_started) * 1000, 1)
 
         during, during_unavailable, sampled_terminal = await _measure_recall_until(

memhub/apps/core/tests/test_capture_deadline.py

@@ -131,3 +131,24 @@ def test_run_as_the_entry_it_ends_itself_while_still_importing(tmp_path) -> None
         _reap([process])
     assert process.returncode == -signal.SIGALRM
     assert time.monotonic() - started < 10
+
+
+def test_with_no_core_a_real_capture_exits_at_once_and_writes_nothing(tmp_path) -> None:
+    # The process a host actually starts: no Core is running for this home,
+    # so the turn is dropped. Nothing may fall back to writing the database.
+    data_dir = tmp_path / "data"
+    env = {
+        key: value for key, value in os.environ.items() if key != "ONE_MEMORY_CAPTURE_DEADLINE_S"
+    }
+    env.update(HOME=str(tmp_path), ONE_MEMORY_DATA_DIR=str(data_dir))
+    payload = b'{"hook_event_name": "UserPromptSubmit", "session_id": "s", "prompt": "hi"}'
+    result = subprocess.run(
+        [sys.executable, "-m", "one_memory.cli", "capture", "workbuddy"],
+        input=payload,
+        capture_output=True,
+        env=env,
+        timeout=60,
+        check=False,
+    )
+    assert (result.returncode, result.stdout, result.stderr) == (0, b"", b"")
+    assert not (data_dir / "one-memory.sqlite3").exists()

memhub/apps/core/tests/test_live_watch.py

@@ -293,6 +293,11 @@ def test_health_states_that_watching_is_layered_on_the_timer(tmp_path: Path) ->
 
         assert live.health(PI_DESCRIPTOR.source_id).mode == "watch_and_polling"
         assert live.health("unknown-source").mode == "watch_and_polling"
+        live.set_watched_sources((PI_DESCRIPTOR.source_id,))
+        assert live._poll_interval(PI_DESCRIPTOR.source_id) == max(
+            live.interval_seconds, 15 * 60
+        )
+        assert live._poll_interval("unknown-source") == live.interval_seconds
         await imports.shutdown()
 
     asyncio.run(scenario())

memhub/apps/core/tests/test_model_probe_operations.py

@@ -91,6 +91,51 @@ def test_reserved_before_transport_and_atomic_result_reopens_without_resending(e
     asyncio.run(scenario())
 
 
+def test_pre_dispatch_failure_marks_operation_failed_and_unfences(env, monkeypatch):
+    store, secrets, profile, ops, calls, respond = env
+    operation = str(uuid4())
+
+    def fail_require(*args, **kwargs):
+        raise RuntimeError("profile load failed")
+
+    prober = ModelProber(store=store, secrets=secrets, transport=httpx.MockTransport(respond))
+    with monkeypatch.context() as patch:
+        patch.setattr(store, "require", fail_require)
+        receipt = asyncio.run(
+            prober.probe(
+                profile.profile_id,
+                operation_id=operation,
+                expected_profile_revision=profile.revision,
+            )
+        )
+
+    assert receipt.state == "failed"
+    assert receipt.code == "model_probe_execution_failed"
+    assert receipt.result is None
+    assert calls == []
+    assert ops.lookup(operation) == receipt
+    assert (
+        asyncio.run(
+            prober.probe(
+                profile.profile_id,
+                operation_id=operation,
+                expected_profile_revision=profile.revision,
+            )
+        )
+        == receipt
+    )
+
+    completed = asyncio.run(
+        prober.probe(
+            profile.profile_id,
+            operation_id=str(uuid4()),
+            expected_profile_revision=profile.revision,
+        )
+    )
+    assert completed.state == "completed"
+    assert len(calls) == 3
+
+
 def test_same_id_and_same_profile_concurrency_refused_before_second_call(env):
     store, secrets, profile, ops, calls, respond = env
 

memhub/apps/core/tests/test_onboarding_profile.py

@@ -149,6 +149,13 @@ def test_progress_patch_and_put_round_trip_only_resumable_choices(tmp_path: Path
             assert replaced.json()["model_profile_id"] == profile_id
             assert (await client.get("/api/v1/onboarding")).json() == replaced.json()
 
+            ultra = await client.put(
+                "/api/v1/onboarding/progress",
+                json={"mode_intent": "ultra", "setup_step": "model"},
+            )
+            assert ultra.status_code == 200
+            assert ultra.json()["mode_intent"] == "ultra"
+
     asyncio.run(scenario())
 
 
@@ -166,7 +173,7 @@ def test_progress_rejects_unknown_or_invalid_fields(tmp_path: Path) -> None:
             )
             invalid_mode = await client.patch(
                 "/api/v1/onboarding/progress",
-                json={"mode_intent": "ultra"},
+                json={"mode_intent": "future"},
             )
 
             assert secret.status_code == 422

memhub/apps/core/tests/test_primary_source_adapters.py

@@ -77,6 +77,36 @@ def test_workbuddy_record_parsing_never_blocks_the_event_loop(tmp_path) -> None:
     asyncio.run(scenario())
 
 
+def test_jsonl_live_probe_listing_is_reused_by_the_import(tmp_path, monkeypatch) -> None:
+    root = tmp_path / ".workbuddy" / "projects"
+    write_jsonl(
+        root / "project" / "session.jsonl",
+        [{"role": "user", "sessionId": "session", "content": "new conversation"}],
+    )
+    adapter = create_workbuddy_adapter(grant("workbuddy", root))
+    from one_memory.imports.sources import common
+
+    calls = 0
+    original = common.list_changed_files
+
+    def counted(*args, **kwargs):
+        nonlocal calls
+        calls += 1
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(common, "list_changed_files", counted)
+
+    async def probe_then_scan():
+        options = ScanOptions()
+        assert await adapter.has_changes(options)
+        return [event async for event in adapter.scan(options)]
+
+    records = evidence(asyncio.run(probe_then_scan()))
+
+    assert [item.evidence.verbatim for item in records] == ["new conversation"]
+    assert calls == 1
+
+
 def test_cursor_store_user_info_envelope_is_not_attributed_to_the_person(tmp_path) -> None:
     """A Cursor store blob can be the host's session context, not the user's words.
 
@@ -1352,6 +1382,73 @@ def test_cursor_transcripts_with_the_same_name_in_two_projects_are_both_kept(
     assert len({item.evidence.source_ordinal for item in records}) == 2
 
 
+def test_cursor_discovery_does_not_enter_non_conversation_trees(tmp_path) -> None:
+    root = tmp_path / ".cursor"
+    write_jsonl(
+        root / "projects" / "project" / "agent-transcripts" / "kept" / "kept.jsonl",
+        [
+            {
+                "role": "user",
+                "message": {"content": [{"type": "text", "text": "kept conversation"}]},
+            }
+        ],
+    )
+    write_jsonl(
+        root
+        / "extensions"
+        / "large-cache"
+        / "agent-transcripts"
+        / "ignored"
+        / "ignored.jsonl",
+        [
+            {
+                "role": "user",
+                "message": {"content": [{"type": "text", "text": "must not be scanned"}]},
+            }
+        ],
+    )
+
+    records = evidence(asyncio.run(scan(CursorUnifiedSourceAdapter(grant=grant("cursor", root)))))
+
+    assert [item.evidence.verbatim for item in records] == ["kept conversation"]
+
+
+def test_cursor_live_probe_listing_is_reused_by_the_import(tmp_path, monkeypatch) -> None:
+    root = tmp_path / ".cursor"
+    write_jsonl(
+        root / "projects" / "project" / "agent-transcripts" / "new" / "new.jsonl",
+        [
+            {
+                "role": "user",
+                "message": {"content": [{"type": "text", "text": "new conversation"}]},
+            }
+        ],
+    )
+    adapter = CursorUnifiedSourceAdapter(grant=grant("cursor", root))
+    from one_memory.imports.adapters import ScanOptions
+    from one_memory.imports.sources import cursor_unified
+
+    calls = 0
+    original = cursor_unified._list_cursor_files
+
+    def counted(*args, **kwargs):
+        nonlocal calls
+        calls += 1
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(cursor_unified, "_list_cursor_files", counted)
+
+    async def probe_then_scan():
+        options = ScanOptions()
+        assert await adapter.has_changes(options)
+        return [event async for event in adapter.scan(options)]
+
+    records = evidence(asyncio.run(probe_then_scan()))
+
+    assert [item.evidence.verbatim for item in records] == ["new conversation"]
+    assert calls == 1
+
+
 def test_cursor_bounded_scans_reuse_the_authorized_file_listing(tmp_path, monkeypatch) -> None:
     root = tmp_path / ".cursor"
     transcript = root / "projects" / "project" / "agent-transcripts" / "session" / "session.jsonl"

memhub/apps/core/tests/test_sdk_api_surface.py

@@ -214,7 +214,15 @@ class RecordingSdk:
                 )
                 and (not kwargs.get("session_ids") or row["session_id"] in kwargs["session_ids"])
             ]
-            return {"vdb": {"memories": rows, "total": len(rows)}}
+            total = len(rows)
+            offset = kwargs.get("offset", 0)
+            limit = kwargs.get("limit", 100)
+            return {
+                "vdb": {
+                    "memories": rows[offset : offset + limit],
+                    "total": total,
+                }
+            }
         rows = [_chat(user_id, *row[:2], *row[3:]) for row in CHAT_ROWS.get(user_id, [])]
         if layers:
             rows = [row for row in rows if row["layer"] in layers]
@@ -712,6 +720,128 @@ def test_raw_lists_active_and_shadow_turns_with_roles_and_hashes(tmp_path, monke
             ["我喜欢绿茶", "也记住了。"],
             ["我叫费天翔", "好的，记住了。"],
         ]
+        cursor = None
+        first_cursor = None
+        cursor_turns = []
+        cursor_calls = len(sdk.all("list_memories"))
+        while True:
+            params = {"unit": "turn", "paging": "cursor", "limit": 1}
+            if cursor is not None:
+                params["cursor"] = cursor
+            response = await client.get("/api/v2/raw", params=params)
+            assert response.status_code == 200, response.text
+            cursor_page = response.json()
+            assert cursor_page["total_exact"] is False
+            assert len(cursor_page["items"]) == 1
+            cursor_turns.append(cursor_page["items"][0]["messages"][0]["content"])
+            cursor = cursor_page["next_cursor"]
+            if first_cursor is None:
+                first_cursor = cursor
+            if cursor is None:
+                assert cursor_page["has_more"] is False
+                break
+            assert cursor_page["has_more"] is True
+        assert cursor_turns == ["我喜欢绿茶", "我叫费天翔", "你好"]
+        assert len(sdk.all("list_memories")) == cursor_calls + 3
+        graph = await client.get("/api/v2/raw/graph", params={"limit": 2})
+        assert graph.status_code == 200, graph.text
+        graph_body = graph.json()
+        assert graph_body["total"] == 3
+        assert graph_body["has_more"] is True
+        assert [item["label"] for item in graph_body["items"]] == [
+            "[user]: 我喜欢绿茶 [assistant]: 也记住了。",
+            "[user]: 我叫费天翔 [assistant]: 好的，记住了。",
+        ]
+        graph_page_2 = (
+            await client.get(
+                "/api/v2/raw/graph",
+                params={
+                    "limit": 2,
+                    "offset": 2,
+                    "snapshot_id": graph_body["snapshot_id"],
+                },
+            )
+        ).json()
+        assert graph_page_2["total"] == 3
+        assert graph_page_2["has_more"] is False
+        assert graph_page_2["items"][0]["turn_id"]
+        assert (
+            await client.get(
+                "/api/v2/raw/graph",
+                params={"limit": 2, "offset": 2},
+            )
+        ).status_code == 422
+        assert (
+            await client.get(
+                "/api/v2/raw/graph",
+                params={
+                    "limit": 2,
+                    "offset": 2,
+                    "snapshot_id": "missing",
+                },
+            )
+        ).status_code == 409
+        inserted = {
+            "memory_id": "raw-new",
+            "content": "[user]: 新消息",
+            "status": "active",
+            "session_id": "s-new",
+            "source": "cursor",
+            "memory_at": 1_790_200_000,
+            "gmt_created": 1_790_200_100,
+        }
+        RAW_ROWS["local"].insert(0, inserted)
+        try:
+            stable_graph_page = (
+                await client.get(
+                    "/api/v2/raw/graph",
+                    params={
+                        "limit": 2,
+                        "offset": 2,
+                        "snapshot_id": graph_body["snapshot_id"],
+                    },
+                )
+            ).json()
+            assert stable_graph_page["total"] == 3
+            assert stable_graph_page["items"][0]["label"] == "[user]: 你好"
+            updated_graph = (await client.get("/api/v2/raw/graph")).json()
+            assert updated_graph["total"] == 4
+            assert updated_graph["items"][0]["label"] == "[user]: 新消息"
+            continued = await client.get(
+                "/api/v2/raw",
+                params={
+                    "unit": "turn",
+                    "paging": "cursor",
+                    "limit": 1,
+                    "cursor": first_cursor,
+                },
+            )
+            assert continued.status_code == 200, continued.text
+            assert continued.json()["items"][0]["messages"][0]["content"] == "我叫费天翔"
+        finally:
+            RAW_ROWS["local"].remove(inserted)
+        assert (
+            await client.get(
+                "/api/v2/raw",
+                params={
+                    "unit": "turn",
+                    "paging": "cursor",
+                    "cursor": first_cursor,
+                    "source": "hermes",
+                },
+            )
+        ).status_code == 422
+        assert (
+            await client.get(
+                "/api/v2/raw",
+                params={
+                    "unit": "turn",
+                    "paging": "cursor",
+                    "cursor": "turn:²:0:0:2::0000000000000000",
+                },
+            )
+        ).status_code == 422
+
         calls_before_refresh = len(sdk.all("list_memories"))
         await client.get("/api/v2/raw", params={"unit": "turn"})
         assert len(sdk.all("list_memories")) == calls_before_refresh + 1

memhub/apps/core/tests/test_sdk_migration_restore.py

@@ -293,6 +293,22 @@ def _retry_succeeds(home: Path, monkeypatch) -> None:
     assert len(list((home / "backups").glob("*-pre-cutover.sdk-bundle"))) == 1
 
 
+def test_evidence_an_older_capture_hook_recreated_is_dropped_on_the_next_start(home):
+    # Builds through 1.0.6 let the hook process open `EvidenceStore`, which
+    # rebuilt the retired tables on an SDK home. Nothing reads them there, and
+    # the next startup migration's leftovers cleanup removes them again.
+    assert _run(home).state == "cutover"
+    database = home / "one-memory.sqlite3"
+    EvidenceStore(database)
+    assert "evidence" in legacy_tables_present(database)
+
+    result = _run(home)
+
+    assert result.state == "complete"
+    assert {"evidence", "evidence_search"} <= set(result.dropped_tables)
+    assert legacy_tables_present(database) == ()
+
+
 def test_a_failure_after_the_cutover_commit_is_not_restored(home, monkeypatch):
     import one_memory.sdk_migration_runner as runner
 

memhub/apps/core/tests/test_service_level_pressure_acceptance.py

@@ -23,9 +23,8 @@ def test_workbuddy_recall_remains_available_during_100k_import(tmp_path, monkeyp
 
     assert result["import_status"] == "completed"
     assert result["stored"] == 100_000
-    assert result["evidence_rows"] == 100_001
+    assert result["evidence_rows"] == 100_000
     assert result["hook_accepted"] is True
-    assert result["hook_stored"] is True
     assert result["hook_visible_ms"] < 10_000
     assert result["recall_sampling_terminal"] is True
     assert result["during_unavailable"] == 0

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

@@ -366,7 +366,7 @@ it("refuses a ui trace from an untrusted window", async () => {
   ).rejects.toThrow(/untrusted_window/);
 });
 
-it("marks a problem and exports a redacted local bundle", async () => {
+it("marks a problem and exports the complete local log bundle", async () => {
   const value = await fixture();
   const mark = await value.handlers.get(
     "one-memory:mark-diagnostic-incident",
@@ -375,6 +375,14 @@ it("marks a problem and exports a redacted local bundle", async () => {
     incident_id: expect.any(String),
     session_id: expect.any(String),
   });
+  await writeFile(
+    path.join(value.dataDir, "logs", "core.log"),
+    "2026-10-14 10:31:00 WARNING database wait\n",
+  );
+  await writeFile(
+    path.join(value.dataDir, "logs", "service-error.log"),
+    "worker failed\n",
+  );
   const exported = await value.handlers.get("one-memory:export-diagnostics")?.(
     {},
   );
@@ -398,6 +406,16 @@ it("marks a problem and exports a redacted local bundle", async () => {
     ),
   );
   expect(summary).toMatchObject({ build: "3800" });
+  const entries = execFileSync(
+    "/usr/bin/unzip",
+    ["-Z1", path.join(value.dataDir, zip)],
+    { encoding: "utf8" },
+  )
+    .trim()
+    .split("\n");
+  expect(entries).toContain("logs/core.log");
+  expect(entries).toContain("logs/service-error.log");
+  expect(entries).toContain("logs/diagnostic-desktop.jsonl");
   value.dispose();
 });
 

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

@@ -196,6 +196,7 @@ export function resolveDiagnosticBuildIdentity(options: {
 
 export async function exportDesktopDiagnostics(
   options: DiagnosticExportOptions,
+  exportOptions: { includeRawLogs?: boolean } = {},
 ) {
   const build = options.buildNumber ?? options.productVersion;
   const target = path.join(
@@ -209,6 +210,7 @@ export async function exportDesktopDiagnostics(
     dataDir: options.dataDir,
     target,
     productVersion: build,
+    includeRawLogs: exportOptions.includeRawLogs === true,
     ...(options.commit === undefined ? {} : { commit: options.commit }),
     ...(options.coreSha256 === undefined
       ? {}
@@ -644,7 +646,7 @@ export function installDiagnosticsIpc(
   options.ipc.handle(EXPORT, async (event, ...args) => {
     if (args.length) throw new Error("diagnostic_arguments_rejected");
     options.requireTrustedWindow(event);
-    return exportDesktopDiagnostics(options);
+    return exportDesktopDiagnostics(options, { includeRawLogs: true });
   });
 
   return () => {

memhub/apps/web/src/FirstImportReview.r6.test.tsx

@@ -371,16 +371,14 @@ it("uses user-facing connection confirmation copy without implementation narrati
     />,
   );
   expect(screen.getByRole("complementary", { name: "连接应用" })).toBeTruthy();
+  expect(screen.getByRole("checkbox", { name: "一键接入应用" })).toBeTruthy();
   expect(
-    screen.getByText(
-      "点击底部按钮后，后台分别接入各应用；某个应用失败不影响其他应用。",
+    screen.queryByText(
+      /点击底部按钮后|选择草稿|按各应用回执|本页任务控制尚未接通/,
     ),
-  ).toBeTruthy();
-  expect(
-    screen.queryByText(/选择草稿|按各应用回执|本页任务控制尚未接通/),
   ).toBeNull();
-  expect(screen.getByText(/下一步选择记忆模式/)).toBeTruthy();
-  expect(screen.getByText(/之后仍可在设置中更改/)).toBeTruthy();
+  expect(screen.queryByText(/下一步选择记忆模式/)).toBeNull();
+  expect(screen.queryByText(/之后仍可在设置中更改/)).toBeNull();
 });
 
 it.each(["paused", "failed", "cancelled", "interrupted"] as const)(
@@ -398,11 +396,7 @@ it.each(["paused", "failed", "cancelled", "interrupted"] as const)(
     expect(
       screen.getByRole("heading", { name: "对话正在汇入，记忆从这里开始" }),
     ).toBeTruthy();
-    expect(
-      screen.getByText(/已保存的对话还在/, {
-        selector: ".first-import-r6-footer-note p",
-      }),
-    ).toBeTruthy();
+    expect(screen.queryByText(/已保存的对话还在/)).toBeNull();
   },
 );
 
@@ -439,9 +433,7 @@ it.each(["stale", "revoked", "missing"])(
         onContinue={vi.fn()}
       />,
     );
-    if (kind === "missing")
-      expect(screen.getByText("导入在后台继续，无需等待。")).toBeTruthy();
-    else expect(screen.queryByText("导入在后台继续，无需等待。")).toBeNull();
+    expect(screen.queryByText("导入在后台继续，无需等待。")).toBeNull();
     expect(
       screen.getByRole("heading", { name: "对话正在汇入，记忆从这里开始" }),
     ).toBeTruthy();

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

@@ -199,8 +199,8 @@ it("keeps the saved count when authority or freshness changes, without a convers
   expect(view.container.querySelector('[data-running="true"]')).toBeTruthy();
   expect(screen.getByText("已保存 7 条消息")).toBeTruthy();
   expect(
-    screen.getAllByText("正在重新核对来源；已保存数量仍按任务回执显示。"),
-  ).toHaveLength(1);
+    screen.queryByText("正在重新核对来源；已保存数量仍按任务回执显示。"),
+  ).toBeNull();
   view.update({
     sourceSnapshot: { confirmedAt: "2026-09-14T00:00:02Z", stale: false },
     jobs: [{ ...job, stored: 20 }],

memhub/apps/web/src/FirstImportReview.tsx

@@ -153,26 +153,6 @@ export function FirstImportReview({
     ids.every((id) => batch.some((job) => job.source_id === id)) &&
     batch.every((job) => job.status === "completed") &&
     !Object.keys(failedSources).length;
-  const allPaused =
-    batch.length > 0 && batch.every((job) => job.status === "paused");
-  const importing =
-    !stale &&
-    batch.some(
-      (job) =>
-        ["pending", "running"].includes(job.status) &&
-        sources.some(
-          (source) => source.source_id === job.source_id && source.authorized,
-        ),
-    );
-  const displayImporting =
-    importing ||
-    (!stale &&
-      !allCompleted &&
-      !allPaused &&
-      batch.length === 0 &&
-      ids.some((id) =>
-        sources.some((source) => source.source_id === id && source.authorized),
-      ));
   const title = "对话正在汇入，记忆从这里开始";
   const hostEligible = importHostEligible(sources, ids);
   const draftReady = !!connectionDraft && !!onConnectionDraftChange;
@@ -282,24 +262,83 @@ export function FirstImportReview({
     <R6ColdStartFrame
       step={2}
       title={text(title)}
-      eyebrow={text("导入进行中 · 顺手连接应用")}
       footer={
-        <>
-          <div className="first-import-r6-footer-note">
+        <div className="first-import-r6-footer-actions">
+          {changing ? (
+            <R6Button
+              onClick={() => {
+                stopBatch.current = true;
+              }}
+            >
+              {text("停止后续操作")}
+            </R6Button>
+          ) : onChangeJob && (canPause || canResume) ? (
+            <R6Button
+              disabled={busy || (stale && !canPause)}
+              onClick={() => void changeBatch(canPause ? "pause" : "resume")}
+            >
+              {canPause ? (
+                <Pause size={16} aria-hidden="true" />
+              ) : (
+                <Play size={16} aria-hidden="true" />
+              )}
+              {text(canPause ? "暂停导入" : "继续导入")}
+            </R6Button>
+          ) : null}
+          {recovery ? (
+            <>
+              <R6Button
+                disabled={busy}
+                onClick={() => {
+                  stopBatch.current = true;
+                  recovery.onSkip();
+                }}
+              >
+                {text(
+                  recovery.destination === "sources"
+                    ? "仍进入应用页"
+                    : recovery.destination === "settings"
+                      ? "仍进入设置"
+                      : "仍进入工作台",
+                )}
+              </R6Button>
+              <R6Button
+                variant="primary"
+                disabled={busy}
+                onClick={() => leave(recovery.destination)}
+              >
+                {text("重试保存并进入")}
+              </R6Button>
+            </>
+          ) : (
+            <R6Button
+              variant="primary"
+              disabled={busy}
+              onClick={() => leave("settings")}
+            >
+              {text("选择记忆模式")}
+            </R6Button>
+          )}
+        </div>
+      }
+    >
+      <div className="first-import-r6-layout">
+        <section
+          className="first-import-r6-main"
+          aria-label={text("导入与原文")}
+        >
+          <div className="first-import-r6-intro">
+            <h2>{text("正在导入你的会话")}</h2>
             <p>
               {text(
                 allCompleted
-                  ? "对话已保存，记忆尚待生成。"
-                  : displayImporting
-                    ? "导入在后台继续，无需等待。"
-                    : stale
-                      ? "正在重新核对来源；已保存数量仍按任务回执显示。"
-                      : allPaused
-                        ? "本次历史导入已暂停，已保存的对话还在。"
-                        : "导入等待处理，已保存的对话还在。",
+                  ? "本次导入已结束。已保存的对话无需重复导入。"
+                  : "后台将持续为你导入，可以放心进入下一步",
               )}
             </p>
-            {(error || actionMessage) && (
+          </div>
+          {(error || actionMessage) && (
+            <div className="first-import-r6-feedback">
               <p
                 role={
                   error?.includes("应用连接") ||
@@ -318,83 +357,8 @@ export function FirstImportReview({
               >
                 {error ? text(error) : actionMessage}
               </p>
-            )}
-          </div>
-          <div className="first-import-r6-footer-actions">
-            {changing ? (
-              <R6Button
-                onClick={() => {
-                  stopBatch.current = true;
-                }}
-              >
-                {text("停止后续操作")}
-              </R6Button>
-            ) : onChangeJob && (canPause || canResume) ? (
-              <R6Button
-                disabled={busy || (stale && !canPause)}
-                onClick={() => void changeBatch(canPause ? "pause" : "resume")}
-              >
-                {canPause ? (
-                  <Pause size={16} aria-hidden="true" />
-                ) : (
-                  <Play size={16} aria-hidden="true" />
-                )}
-                {text(canPause ? "暂停导入" : "继续导入")}
-              </R6Button>
-            ) : null}
-            {recovery ? (
-              <>
-                <R6Button
-                  disabled={busy}
-                  onClick={() => {
-                    stopBatch.current = true;
-                    recovery.onSkip();
-                  }}
-                >
-                  {text(
-                    recovery.destination === "sources"
-                      ? "仍进入应用页"
-                      : recovery.destination === "settings"
-                        ? "仍进入设置"
-                        : "仍进入工作台",
-                  )}
-                </R6Button>
-                <R6Button
-                  variant="primary"
-                  disabled={busy}
-                  onClick={() => leave(recovery.destination)}
-                >
-                  {text("重试保存并进入")}
-                </R6Button>
-              </>
-            ) : (
-              <R6Button
-                variant="primary"
-                disabled={busy}
-                onClick={() => leave("settings")}
-              >
-                {text("选择记忆模式")}
-              </R6Button>
-            )}
-          </div>
-        </>
-      }
-    >
-      <div className="first-import-r6-layout">
-        <section
-          className="first-import-r6-main"
-          aria-label={text("导入与原文")}
-        >
-          <p className="first-import-r6-intro">
-            {text(
-              allCompleted
-                ? "本次导入已结束。已保存的对话无需重复导入。"
-                : "对话先保存在本机。你可以同时设置后续连接。",
-            )}
-          </p>
-          <p className="first-import-r6-subintro">
-            {text("下一步选择记忆模式；之后仍可在设置中更改。")}
-          </p>
+            </div>
+          )}
           {historyWindowLimited && (
             <p className="first-import-r6-history-window" role="status">
               {t("onboardingHistoryWindow")}
@@ -406,46 +370,39 @@ export function FirstImportReview({
             jobs={batch}
             stale={progressStale}
           />
-          <section
-            className="first-import-r6-feed"
-            aria-label={text("导入说明")}
-          >
-            <h2>{text("正在导入你的会话")}</h2>
-            <p className="first-import-r6-feed-status">
-              {text("后台将持续为你导入，可以放心进入下一步")}
-            </p>
-            {Object.keys(failedSources).length > 0 && (
-              <section
-                className="first-import-r6-failures"
-                aria-label={text("未开始的导入")}
+          {Object.keys(failedSources).length > 0 && (
+            <section
+              className="first-import-r6-failures"
+              aria-label={text("未开始的导入")}
+            >
+              {Object.keys(failedSources).map((id) => (
+                <p key={id}>
+                  {sources.find((source) => source.source_id === id)
+                    ?.display_name ?? id}{" "}
+                  {text("未能开始导入，其他已接受任务不受影响。")}
+                </p>
+              ))}
+              <R6Button
+                variant="quiet"
+                disabled={busy}
+                onClick={() => leave("sources")}
               >
-                {Object.keys(failedSources).map((id) => (
-                  <p key={id}>
-                    {sources.find((source) => source.source_id === id)
-                      ?.display_name ?? id}{" "}
-                    {text("未能开始导入，其他已接受任务不受影响。")}
-                  </p>
-                ))}
-                <R6Button
-                  variant="quiet"
-                  disabled={busy}
-                  onClick={() => leave("sources")}
-                >
-                  {text("查看未导入的应用")}
-                </R6Button>
-              </section>
-            )}
-          </section>
+                {text("查看未导入的应用")}
+              </R6Button>
+            </section>
+          )}
         </section>
         <aside
           className="first-import-r6-options"
           aria-label={text("连接应用")}
         >
-          <p className="first-import-r6-eyebrow">{text("让记忆继续生长")}</p>
-          <h2>{text("连接你的应用")}</h2>
-          <p className="first-import-r6-options-intro">
-            {text("适用于本次选择且支持的应用。")}
-          </p>
+          <div className="first-import-r6-options-head">
+            <p className="first-import-r6-eyebrow">{text("让记忆继续生长")}</p>
+            <h2>{text("连接你的应用")}</h2>
+            <p className="first-import-r6-options-intro">
+              {text("适用于本次选择且支持的应用。")}
+            </p>
+          </div>
           <SelectionTile
             title={text(
               hostConnectionAvailable ? "一键接入应用" : "测试实例不接入应用",
@@ -481,13 +438,11 @@ export function FirstImportReview({
               {text(connectionNote)}
             </p>
           )}
-          <p className="first-import-r6-options-note">
-            {text(
-              draftReady
-                ? "点击底部按钮后，后台分别接入各应用；某个应用失败不影响其他应用。"
-                : "暂时无法连接应用，当前不会安装连接。",
-            )}
-          </p>
+          {!draftReady && (
+            <p className="first-import-r6-options-note">
+              {text("暂时无法连接应用，当前不会安装连接。")}
+            </p>
+          )}
         </aside>
       </div>
     </R6ColdStartFrame>

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

@@ -226,6 +226,7 @@ describe("HealthPanel", () => {
     });
     vi.spyOn(window, "prompt").mockReturnValue("蓝莓没出来");
     render(<HealthPanel imports={imports()} />);
+    expect(screen.getByText(/可能包含会话正文和本机路径/)).toBeTruthy();
 
     fireEvent.click(screen.getByRole("button", { name: "记录问题时间点" }));
     expect(await screen.findByText(/问题编号已复制/)).toBeTruthy();

memhub/apps/web/src/HealthPanel.tsx

@@ -298,6 +298,7 @@ export function HealthPanel({ imports }: { imports: ImportState }) {
           <Download size={16} aria-hidden="true" />
           {t("nativeExportLogs")}
         </R6Button>
+        <p>{t("把本机运行日志打包成一个文件，发给开发排查。")}</p>
       </div>
 
       <section className="health-block" aria-label={t("healthLocal")}>

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

@@ -62,6 +62,30 @@ vi.mock("./MemoryGraph3D", () => ({
     </div>
   ),
 }));
+vi.mock("./RawConversationGraph3D", () => ({
+  RawConversationGraph3D: ({
+    graph,
+    selectedNodeId,
+    onSelectNode,
+  }: {
+    graph: MemoryGraphResponse;
+    selectedNodeId: string | null;
+    onSelectNode(node: MemoryGraphNode): void;
+  }) => (
+    <div data-testid="canvas" data-selected={selectedNodeId}>
+      {graph.nodes.map((node) => (
+        <button
+          key={node.node_id}
+          type="button"
+          aria-label={`图中选择 ${node.label}`}
+          onClick={() => onSelectNode(node)}
+        >
+          {node.label}
+        </button>
+      ))}
+    </div>
+  ),
+}));
 afterEach(() => {
   cleanup();
   vi.resetAllMocks();
@@ -491,6 +515,7 @@ function Host({
   onViewHistory,
   onConfigureModel = () => {},
   libraryView,
+  raw = false,
 }: {
   simplified?: boolean;
   date?: string | null;
@@ -509,6 +534,7 @@ function Host({
   onViewHistory?(): void;
   onConfigureModel?(): void;
   libraryView?: Parameters<typeof MemoryMap>[0]["libraryView"];
+  raw?: boolean;
 } = {}) {
   const [detail, setDetail] = useState<MemoryDetail | null>(null);
   const [detailLoad, setDetailLoad] = useState<{
@@ -518,6 +544,7 @@ function Host({
   return (
     <MemoryMap
       simplified={simplified}
+      contentKind={raw ? "raw" : "memory"}
       libraryView={libraryView}
       hidden={hidden}
       overlayBlocked={overlayBlocked}
@@ -587,6 +614,61 @@ function Host({
     />
   );
 }
+
+it("windows raw rows and automatically continues near the bottom", () => {
+  const items = Array.from({ length: 150 }, (_, index) => ({
+    ...memories[0],
+    memory_id: `raw-${index}`,
+    content: `原始会话 ${index}`,
+  }));
+  const onMore = vi.fn();
+  const sourceIds = Object.fromEntries(
+    items.map((item) => [item.memory_id, ["cursor"]]),
+  );
+  render(
+    <Host
+      simplified
+      raw
+      items={items}
+      libraryView={{
+        query: "",
+        source: "",
+        page: {
+          items,
+          total: 1_600,
+          offset: 0,
+          limit: 50,
+          source_ids_by_memory: sourceIds,
+        },
+        loading: false,
+        failed: false,
+        stale: false,
+        cursorPaging: true,
+        hasMore: true,
+        onQuery: vi.fn(),
+        onSource: vi.fn(),
+        resetPage: vi.fn(),
+        onPage: vi.fn(),
+        onMore,
+        onRetry: vi.fn(),
+      }}
+    />,
+  );
+  const list = screen.getByRole("list", { name: "原始对话" });
+  Object.defineProperties(list, {
+    clientHeight: { configurable: true, value: 500 },
+    scrollHeight: { configurable: true, value: 17_400 },
+    scrollTop: { configurable: true, writable: true, value: 16_500 },
+  });
+  fireEvent.scroll(list);
+
+  expect(onMore).toHaveBeenCalledTimes(1);
+  expect(document.querySelectorAll("[data-memory-id]").length).toBeLessThan(30);
+  expect(screen.getByRole("button", { name: "加载更多" }).classList).toContain(
+    "map-load-more",
+  );
+});
+
 it("does not present an unverified empty page as zero memories", () => {
   const page = {
     items: [],

memhub/apps/web/src/MemoryMap.tsx

@@ -16,6 +16,7 @@ import type {
 import type { GuiLocale } from "@one-memory/i18n";
 import {
   ArrowUp,
+  ChevronDown,
   ChevronLeft,
   ChevronRight,
   FileText,
@@ -51,6 +52,7 @@ import {
 } from "./memory-map-model";
 import { OptionMenu } from "./OptionMenu";
 import { R6Button } from "./R6Controls";
+import { RawConversationGraph3D } from "./RawConversationGraph3D";
 import { SelectedMemoryDetail } from "./SelectedMemoryDetail";
 import { SelectedRawDetail } from "./SelectedRawDetail";
 import { sourceNameOr } from "./source-label";
@@ -106,16 +108,21 @@ type Props = {
     /** The graph for the current source/query scope has not arrived yet. */
     graphLoading?: boolean;
     graphFailed?: boolean;
+    graphLoaded?: number;
+    graphTotal?: number;
     stale: boolean;
     settledSource?: string;
     settledQuery?: string;
     requestedOffset?: number;
+    cursorPaging?: boolean;
+    hasMore?: boolean;
     /** The source id the SDK uses for "no source given" (shown as 未识别来源). */
     unattributedSource?: string;
     onQuery(value: string): void;
     onSource(value: string): void;
     resetPage(): void;
     onPage(offset: number): void;
+    onMore?(): void;
     onRetry(): void;
   };
 };
@@ -176,6 +183,8 @@ const SCENE_LABELS: Record<SdkMemoryScene, string> = {
   working: "工作",
   coding: "编码",
 };
+const RAW_ROW_HEIGHT = 116;
+const RAW_LIST_OVERSCAN = 6;
 
 export function MemoryMap(props: Props) {
   const { locale, text, count, plain } = useMemoryLanguage();
@@ -254,6 +263,10 @@ export function MemoryMap(props: Props) {
   const pane = useRef<HTMLElement>(null);
   const memoryList = useRef<HTMLUListElement>(null);
   const inspectorBody = useRef<HTMLDivElement>(null);
+  const [rawListWindow, setRawListWindow] = useState({
+    start: 0,
+    end: 20,
+  });
   const openedDefault = useRef(false);
   const scrollSelection = useRef(false);
   const controlledSource = library
@@ -339,6 +352,33 @@ export function MemoryMap(props: Props) {
       ),
     [active, group, search, serverPaged, axis, groupKey],
   );
+  const rawWindowed = raw && !!library?.cursorPaging && filtered.length > 100;
+  const visibleMemories = rawWindowed
+    ? filtered.slice(rawListWindow.start, rawListWindow.end)
+    : filtered;
+  const rawTopSpace = rawWindowed ? rawListWindow.start * RAW_ROW_HEIGHT : 0;
+  const rawBottomSpace = rawWindowed
+    ? Math.max(0, filtered.length - rawListWindow.end) * RAW_ROW_HEIGHT
+    : 0;
+  const updateRawListWindow = useCallback(
+    (element: HTMLUListElement) => {
+      if (!rawWindowed) return;
+      const first = Math.max(
+        0,
+        Math.floor(element.scrollTop / RAW_ROW_HEIGHT) - RAW_LIST_OVERSCAN,
+      );
+      const visible = Math.ceil(element.clientHeight / RAW_ROW_HEIGHT);
+      setRawListWindow({
+        start: first,
+        end: Math.min(filtered.length, first + visible + RAW_LIST_OVERSCAN * 2),
+      });
+    },
+    [filtered.length, rawWindowed],
+  );
+  useLayoutEffect(() => {
+    if (rawWindowed && memoryList.current)
+      updateRawListWindow(memoryList.current);
+  }, [rawWindowed, updateRawListWindow]);
   const projection = useMemo(() => {
     // Until the new scope's graph arrives (or after it failed), drawing the
     // previous scope's graph would show the wrong source.
@@ -354,7 +394,7 @@ export function MemoryMap(props: Props) {
     // left-hand list window. Projecting the graph back down to the current
     // 20-row page made "All applications" look like whichever source happened
     // to dominate that page. Keyword search is intentionally page-scoped.
-    if (serverPaged && !library?.query) {
+    if (serverPaged && (!library?.query || raw)) {
       return (
         baseGraph ??
         projectMap(
@@ -406,6 +446,7 @@ export function MemoryMap(props: Props) {
     search,
     sources,
     serverPaged,
+    raw,
     library?.query,
     library?.graphLoading,
     library?.graphFailed,
@@ -1023,11 +1064,42 @@ export function MemoryMap(props: Props) {
         )}
         <ul
           ref={memoryList}
-          className="map-memory-list"
+          className={`map-memory-list${raw ? " raw" : ""}`}
           aria-label={raw ? t("memory:原始对话") : text("地图记忆列表")}
           id="memory-pane-memories"
+          onScroll={(event) => {
+            const element = event.currentTarget;
+            updateRawListWindow(element);
+            if (
+              library?.cursorPaging &&
+              library.hasMore &&
+              !pageTransitioning &&
+              element.scrollHeight - element.scrollTop - element.clientHeight <
+                element.clientHeight
+            )
+              library.onMore?.();
+          }}
+          onWheel={(event) => {
+            const element = event.currentTarget;
+            if (
+              event.deltaY > 0 &&
+              library?.cursorPaging &&
+              library.hasMore &&
+              !pageTransitioning &&
+              element.scrollHeight - element.scrollTop - element.clientHeight <
+                8
+            )
+              library.onMore?.();
+          }}
         >
-          {filtered.map((m) => (
+          {rawTopSpace ? (
+            <li
+              className="map-memory-spacer"
+              style={{ height: rawTopSpace }}
+              aria-hidden="true"
+            />
+          ) : null}
+          {visibleMemories.map((m) => (
             <li key={m.memory_id} data-memory-id={m.memory_id}>
               <button
                 type="button"
@@ -1083,6 +1155,13 @@ export function MemoryMap(props: Props) {
               </button>
             </li>
           ))}
+          {rawBottomSpace ? (
+            <li
+              className="map-memory-spacer"
+              style={{ height: rawBottomSpace }}
+              aria-hidden="true"
+            />
+          ) : null}
         </ul>
         {library?.failed && (
           <div role="alert">
@@ -1131,62 +1210,93 @@ export function MemoryMap(props: Props) {
               aria-busy={pageTransitioning || undefined}
               className="map-pagination"
             >
-              <button
-                type="button"
-                className="quiet map-tool"
-                aria-label={text("上一页记忆")}
-                title={text("上一页记忆")}
-                disabled={pageTransitioning || library.page.offset === 0}
-                onClick={() => {
-                  if (axis === "topic") setGroupKey("");
-                  if (library.page) {
-                    const offset = library.page.offset - library.page.limit;
-                    setPageRetrying(false);
-                    pageRetrySawLoading.current = false;
-                    setPendingPageOffset(offset);
-                    library.onPage(offset);
-                  }
-                }}
-              >
-                <ChevronLeft size={16} aria-hidden="true" />
-              </button>
-              <span>
-                {text(
-                  "共 {count} 条，第 {page} / {pages} 页",
-                  {
-                    count: count(library.page.total),
-                    page:
-                      library.page.total === 0
-                        ? 0
-                        : Math.floor(library.page.offset / library.page.limit) +
-                          1,
-                    pages: Math.ceil(library.page.total / library.page.limit),
-                  },
-                  library.page.total,
-                )}
-              </span>
-              <button
-                type="button"
-                className="quiet map-tool"
-                aria-label={text("下一页记忆")}
-                title={text("下一页记忆")}
-                disabled={
-                  pageTransitioning ||
-                  library.page.offset + library.page.limit >= library.page.total
-                }
-                onClick={() => {
-                  if (axis === "topic") setGroupKey("");
-                  if (library.page) {
-                    const offset = library.page.offset + library.page.limit;
-                    setPageRetrying(false);
-                    pageRetrySawLoading.current = false;
-                    setPendingPageOffset(offset);
-                    library.onPage(offset);
-                  }
-                }}
-              >
-                <ChevronRight size={16} aria-hidden="true" />
-              </button>
+              {library.cursorPaging ? (
+                library.hasMore ? (
+                  <button
+                    type="button"
+                    className="map-load-more"
+                    disabled={pageTransitioning}
+                    aria-label={
+                      pageTransitioning ? text("正在读取…") : text("加载更多")
+                    }
+                    title={
+                      pageTransitioning ? text("正在读取…") : text("加载更多")
+                    }
+                    onClick={() => library.onMore?.()}
+                  >
+                    <ChevronDown
+                      size={18}
+                      aria-hidden="true"
+                      className={pageTransitioning ? "loading" : undefined}
+                    />
+                  </button>
+                ) : (
+                  <span>{text("已加载全部")}</span>
+                )
+              ) : (
+                <>
+                  <button
+                    type="button"
+                    className="quiet map-tool"
+                    aria-label={text("上一页记忆")}
+                    title={text("上一页记忆")}
+                    disabled={pageTransitioning || library.page.offset === 0}
+                    onClick={() => {
+                      if (axis === "topic") setGroupKey("");
+                      if (library.page) {
+                        const offset = library.page.offset - library.page.limit;
+                        setPageRetrying(false);
+                        pageRetrySawLoading.current = false;
+                        setPendingPageOffset(offset);
+                        library.onPage(offset);
+                      }
+                    }}
+                  >
+                    <ChevronLeft size={16} aria-hidden="true" />
+                  </button>
+                  <span>
+                    {text(
+                      "共 {count} 条，第 {page} / {pages} 页",
+                      {
+                        count: count(library.page.total),
+                        page:
+                          library.page.total === 0
+                            ? 0
+                            : Math.floor(
+                                library.page.offset / library.page.limit,
+                              ) + 1,
+                        pages: Math.ceil(
+                          library.page.total / library.page.limit,
+                        ),
+                      },
+                      library.page.total,
+                    )}
+                  </span>
+                  <button
+                    type="button"
+                    className="quiet map-tool"
+                    aria-label={text("下一页记忆")}
+                    title={text("下一页记忆")}
+                    disabled={
+                      pageTransitioning ||
+                      library.page.offset + library.page.limit >=
+                        library.page.total
+                    }
+                    onClick={() => {
+                      if (axis === "topic") setGroupKey("");
+                      if (library.page) {
+                        const offset = library.page.offset + library.page.limit;
+                        setPageRetrying(false);
+                        pageRetrySawLoading.current = false;
+                        setPendingPageOffset(offset);
+                        library.onPage(offset);
+                      }
+                    }}
+                  >
+                    <ChevronRight size={16} aria-hidden="true" />
+                  </button>
+                </>
+              )}
             </nav>
           )}
         {!library && loaded && !filtered.length && (search || groupKey) && (
@@ -1213,19 +1323,38 @@ export function MemoryMap(props: Props) {
             <h2>
               {props.simplified
                 ? raw
-                  ? t("memory:原始对话")
+                  ? text("来源归属")
                   : text("记忆关联")
                 : label}
             </h2>
-            {props.simplified && (
-              <p className="selected-graph-subtitle">
-                {projection.nodes.length
-                  ? text("来源归属")
-                  : raw
-                    ? t("sdk.raw.empty")
-                    : text("可在沉淀记忆后查看视图")}
+            {props.simplified && raw && library?.graphTotal !== undefined ? (
+              <p className="selected-graph-subtitle" role="status">
+                {library.graphLoading
+                  ? `${text("正在读取记忆地图…")} ${new Intl.NumberFormat(
+                      locale,
+                    ).format(
+                      library.graphLoaded ?? 0,
+                    )} / ${new Intl.NumberFormat(locale).format(
+                      library.graphTotal,
+                    )}`
+                  : `${new Intl.NumberFormat(locale).format(
+                      library.graphLoaded ?? 0,
+                    )} / ${new Intl.NumberFormat(locale).format(
+                      library.graphTotal,
+                    )}`}
               </p>
-            )}
+            ) : null}
+            {props.simplified &&
+              (!raw || !projection.nodes.length) &&
+              !(raw && library?.graphLoading) && (
+                <p className="selected-graph-subtitle">
+                  {projection.nodes.length
+                    ? text("来源归属")
+                    : raw
+                      ? t("sdk.raw.empty")
+                      : text("可在沉淀记忆后查看视图")}
+                </p>
+              )}
           </div>
           {compact && (activeId || selectedSource) && !inspectorOpen && (
             <button
@@ -1245,14 +1374,25 @@ export function MemoryMap(props: Props) {
         </header>
         <div className="map-canvas" data-tour-id="memory-map-canvas">
           {projection.nodes.length && (!props.simplified || !hidden) ? (
-            <MemoryGraph3D
-              graph={projection}
-              selectedNodeId={
-                visibleGroupNode?.node_id ??
-                (activeId ? `memory:${activeId}` : null)
-              }
-              onSelectNode={pickNode}
-            />
+            raw ? (
+              <RawConversationGraph3D
+                graph={projection}
+                selectedNodeId={
+                  visibleGroupNode?.node_id ??
+                  (activeId ? `memory:${activeId}` : null)
+                }
+                onSelectNode={pickNode}
+              />
+            ) : (
+              <MemoryGraph3D
+                graph={projection}
+                selectedNodeId={
+                  visibleGroupNode?.node_id ??
+                  (activeId ? `memory:${activeId}` : null)
+                }
+                onSelectNode={pickNode}
+              />
+            )
           ) : (
             <div className="map-empty-stage">
               <Network size={32} strokeWidth={1} />

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

@@ -0,0 +1,70 @@
+// @vitest-environment jsdom
+
+import { cleanup, render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, expect, it, vi } from "vitest";
+import { LanguageProvider } from "./gui-language";
+import { MemoryModeCards } from "./MemoryModeCards";
+
+afterEach(cleanup);
+
+it("shows every mode feature and reveals Ultra scheduling after selection", async () => {
+  const onChange = vi.fn();
+  const user = userEvent.setup();
+  const view = (value: "lite" | "pro" | "ultra") => (
+    <LanguageProvider>
+      <MemoryModeCards
+        aria-label="记忆模式"
+        value={value}
+        layout="rows"
+        onChange={onChange}
+        ultraDetail={
+          <div>
+            <strong>每天自动整合</strong>
+            <small>默认 03:00，可在设置中修改。</small>
+          </div>
+        }
+      />
+    </LanguageProvider>
+  );
+  const { rerender } = render(view("pro"));
+
+  expect(screen.getByRole("radiogroup", { name: "记忆模式" })).toBeTruthy();
+  expect(screen.getAllByRole("radio")).toHaveLength(3);
+  expect(screen.getByText("不调用生成模型")).toBeTruthy();
+  expect(screen.getByText("沉淀高级记忆")).toBeTruthy();
+  expect(screen.getByText("增强关联召回")).toBeTruthy();
+  expect(screen.queryByText("每天自动整合")).toBeNull();
+
+  await user.click(screen.getByRole("radio", { name: /深度记忆/ }));
+  expect(onChange).toHaveBeenCalledWith("ultra", expect.any(HTMLInputElement));
+
+  rerender(view("ultra"));
+  expect(screen.getByText("每天自动整合")).toBeTruthy();
+});
+
+it("preserves per-mode disabled behavior", () => {
+  render(
+    <LanguageProvider>
+      <MemoryModeCards
+        aria-label="记忆模式"
+        value="lite"
+        disabled={(mode) => mode !== "lite"}
+        onChange={vi.fn()}
+      />
+    </LanguageProvider>,
+  );
+
+  expect(screen.getByRole("radio", { name: /基础记忆/ })).toHaveProperty(
+    "disabled",
+    false,
+  );
+  expect(screen.getByRole("radio", { name: /智能记忆/ })).toHaveProperty(
+    "disabled",
+    true,
+  );
+  expect(screen.getByRole("radio", { name: /深度记忆/ })).toHaveProperty(
+    "disabled",
+    true,
+  );
+});

memhub/apps/web/src/MemoryModeCards.tsx

@@ -0,0 +1,131 @@
+import type { MemoryPipelineMode } from "@one-memory/contracts";
+import { Check, Clock3 } from "lucide-react";
+import { type ReactNode, useId } from "react";
+import { MODE_COPY } from "./memory-mode-ui";
+import { useOnboardingTranslation } from "./onboarding-language";
+import "./memory-mode-cards.css";
+
+const MODES: Array<{
+  id: MemoryPipelineMode;
+  index: string;
+  description: string;
+}> = [
+  {
+    id: "lite",
+    index: "01",
+    description: "不调用生成模型。保存并检索原始对话，不再生成高级记忆。",
+  },
+  {
+    id: "pro",
+    index: "02",
+    description: "使用当前模型从新对话中提取事实、偏好和计划。",
+  },
+  {
+    id: "ultra",
+    index: "03",
+    description: "在智能记忆之上使用知识图谱，并默认每天 03:00 自动整合记忆。",
+  },
+];
+
+export function MemoryModeCards({
+  value,
+  current,
+  currentBadge,
+  disabled = false,
+  layout = "grid",
+  onChange,
+  ultraDetail,
+  "aria-label": ariaLabel,
+  "aria-busy": ariaBusy,
+}: {
+  value: MemoryPipelineMode | null;
+  current?: MemoryPipelineMode;
+  currentBadge?: ReactNode;
+  disabled?: boolean | ((mode: MemoryPipelineMode) => boolean);
+  layout?: "grid" | "rows";
+  onChange(mode: MemoryPipelineMode, control: HTMLInputElement): void;
+  ultraDetail?: ReactNode;
+  "aria-label": string;
+  "aria-busy"?: boolean;
+}) {
+  const { text } = useOnboardingTranslation();
+  const name = useId();
+  const unavailable = (mode: MemoryPipelineMode) =>
+    typeof disabled === "function" ? disabled(mode) : disabled;
+
+  return (
+    <div
+      className={`memory-mode-cards memory-mode-cards--${layout}`}
+      role="radiogroup"
+      aria-label={ariaLabel}
+      aria-busy={ariaBusy || undefined}
+    >
+      <div className="memory-mode-card-list">
+        {MODES.map((mode) => {
+          const selected = value === mode.id;
+          const modeDisabled = unavailable(mode.id);
+          const localizedTitle = text(MODE_COPY[mode.id].title);
+          const title = localizedTitle.replace(
+            /\s*[（(](?:lite|pro|ultra)[)）]\s*$/i,
+            "",
+          );
+          const features = text(MODE_COPY[mode.id].description).split(
+            /\s*·\s*/,
+          );
+          return (
+            <div
+              key={mode.id}
+              className="memory-mode-card"
+              data-mode={mode.id}
+              data-selected={selected || undefined}
+              data-current={current === mode.id || undefined}
+              data-disabled={modeDisabled || undefined}
+            >
+              <label className="memory-mode-card-choice">
+                <input
+                  type="radio"
+                  name={name}
+                  value={mode.id}
+                  aria-label={localizedTitle}
+                  checked={selected}
+                  disabled={modeDisabled}
+                  onChange={(event) => onChange(mode.id, event.currentTarget)}
+                />
+                <span className="memory-mode-title">
+                  <span className="memory-mode-index">{mode.index}</span>
+                  <strong>{title}</strong>
+                  <span className="memory-mode-tier">
+                    {mode.id.toUpperCase()}
+                  </span>
+                  {current === mode.id && currentBadge ? (
+                    <span className="memory-mode-current">{currentBadge}</span>
+                  ) : null}
+                  <span className="memory-mode-radio" aria-hidden="true">
+                    {selected ? <Check size={13} /> : null}
+                  </span>
+                </span>
+                <span className="memory-mode-description">
+                  {text(mode.description)}
+                </span>
+                <span className="memory-mode-features">
+                  {features.map((feature) => (
+                    <span key={feature}>
+                      <i aria-hidden="true" />
+                      {text(feature)}
+                    </span>
+                  ))}
+                </span>
+                {mode.id === "ultra" && selected && ultraDetail ? (
+                  <div className="memory-mode-detail">
+                    <Clock3 size={14} aria-hidden="true" />
+                    <div>{ultraDetail}</div>
+                  </div>
+                ) : null}
+              </label>
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}

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

@@ -96,7 +96,7 @@ it("renders all settings modes as one grouped shared choice list", async () => {
   expect(within(group).getAllByRole("radio")).toHaveLength(3);
   expect(
     within(group).getByText("当前模式").closest("label")?.textContent,
-  ).toContain("智能记忆（pro）");
+  ).toContain("智能记忆PRO");
 });
 
 it("confirms the data effects before switching to lite", async () => {
@@ -115,9 +115,7 @@ it("confirms the data effects before switching to lite", async () => {
   expect(screen.getByText("搜索范围")).toBeTruthy();
   expect(setMemoryMode).not.toHaveBeenCalled();
 
-  await user.click(
-    screen.getByRole("button", { name: "切换到基础记忆（lite）" }),
-  );
+  await user.click(screen.getByRole("button", { name: "确认选择" }));
   await waitFor(() => expect(setMemoryMode).toHaveBeenCalledWith("lite"));
   await waitFor(() =>
     expect(document.activeElement).toBe(
@@ -139,7 +137,7 @@ it("traps modal focus, closes on Escape and restores the mode-card focus", async
   expect(outside.inert).toBe(true);
   await user.keyboard("{Shift>}{Tab}{/Shift}");
   expect(document.activeElement).toBe(
-    screen.getByRole("button", { name: "切换到基础记忆（lite）" }),
+    screen.getByRole("button", { name: "确认选择" }),
   );
   await user.keyboard("{Escape}");
 
@@ -155,9 +153,7 @@ it("keeps focus inside the modal while the mode change is pending", async () =>
   const user = userEvent.setup();
   render(<MemoryModeSettings hasActiveModel onConfigureModel={vi.fn()} />);
   await chooseMode(user, /基础记忆（lite）/);
-  await user.click(
-    screen.getByRole("button", { name: "切换到基础记忆（lite）" }),
-  );
+  await user.click(screen.getByRole("button", { name: "确认选择" }));
 
   const modal = screen.getByRole("dialog");
   await waitFor(() => expect(document.activeElement).toBe(modal));
@@ -229,11 +225,11 @@ it("explains model cost, search scope and the next step before switching to ultr
 
   expect(screen.getByText("模型调用与费用")).toBeTruthy();
   expect(screen.getByText("搜索范围")).toBeTruthy();
-  expect(screen.getByText("切换后")).toBeTruthy();
+  expect(screen.getByText("选择后")).toBeTruthy();
   expect(screen.getByText(/已经处理完的旧对话不会补做/)).toBeTruthy();
   expect(screen.getByText("知识图谱")).toBeTruthy();
   expect(screen.getAllByText("已有数据")).toHaveLength(1);
-  expect(screen.getByText(/切换本身不会立即整合/)).toBeTruthy();
+  expect(screen.getByText(/选择模式本身不会立即整合/)).toBeTruthy();
 });
 
 it("distinguishes regular memories from higher-level Ultra data when switching to pro", async () => {
@@ -279,9 +275,7 @@ it("focuses the Evolve settings after switching to ultra", async () => {
   vi.mocked(getMemoryMode).mockResolvedValue(state("ultra"));
 
   await chooseMode(user, /深度记忆（ultra）/);
-  await user.click(
-    screen.getByRole("button", { name: "切换到深度记忆（ultra）" }),
-  );
+  await user.click(screen.getByRole("button", { name: "确认选择" }));
 
   await waitFor(() =>
     expect(document.activeElement?.getAttribute("id")).toContain("-evolve"),
@@ -498,14 +492,12 @@ it("keeps a failed switch explanation inside the open confirmation dialog", asyn
   render(<MemoryModeSettings hasActiveModel onConfigureModel={vi.fn()} />);
 
   await chooseMode(user, /深度记忆（ultra）/);
-  await user.click(
-    screen.getByRole("button", { name: "切换到深度记忆（ultra）" }),
-  );
+  await user.click(screen.getByRole("button", { name: "确认选择" }));
 
   const dialog = screen.getByRole("dialog");
   expect(
     await within(dialog).findByText(
-      "当前安装缺少知识图谱组件，无法开启 ultra。",
+      "当前安装缺少知识图谱组件，无法选择 ultra。",
     ),
   ).toBeTruthy();
 });
@@ -541,7 +533,7 @@ it("blocks mode and Evolve controls during embedding maintenance", async () => {
 
   expect(
     await screen.findByText(
-      "正在检查或切换向量模型，完成前不能切换模式或手动整合。",
+      "正在检查或切换向量模型，完成前不能选择模式或手动整合。",
     ),
   ).toBeTruthy();
   expect(

memhub/apps/web/src/MemoryModeSettings.tsx

@@ -25,97 +25,12 @@ import {
   commitConfirmedMemoryMode,
   issueConfirmedModeTicket,
 } from "./confirmed-memory-mode";
-import { MemoryModeChoiceList } from "./MemoryModeChoiceList";
+import { MemoryModeCards } from "./MemoryModeCards";
+import { BLOCKER_COPY, MemoryModeConfirmDialog } from "./memory-mode-ui";
 import { useOnboardingTranslation } from "./onboarding-language";
-import { R6Button, R6Switch } from "./R6Controls";
+import { R6Button } from "./R6Controls";
 import { R6StateRecovery } from "./R6StateRecovery";
-import { TimePicker } from "./TimePicker";
-
-const MODE_COPY: Record<
-  MemoryPipelineMode,
-  { title: string; description: string }
-> = {
-  lite: {
-    title: "基础记忆（lite）",
-    description: "保存原始对话 · 不调用生成模型 · 搜索原始会话",
-  },
-  pro: {
-    title: "智能记忆（pro）",
-    description: "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆",
-  },
-  ultra: {
-    title: "深度记忆（ultra）",
-    description: "智能记忆 + 知识图谱 · 可自动 Evolve · 增强关联召回",
-  },
-};
-
-function planRows(plan: MemoryModePlan) {
-  const rows = [
-    {
-      label: "新对话",
-      content:
-        plan.capabilities.content_plane === "raw"
-          ? "之后只保存原始对话，不再生成新记忆。"
-          : plan.capabilities.graph_enabled
-            ? "新对话会整理成记忆并写入知识图谱。"
-            : "新对话会由模型整理成记忆。",
-    },
-    {
-      label: "模型调用与费用",
-      content: plan.capabilities.generation_required
-        ? plan.capabilities.evolve_available
-          ? "会调用当前生成模型；自动整合可能产生额外费用。切换本身不会立即整合。"
-          : "会调用当前生成模型，可能产生服务商费用。"
-        : "不调用生成模型，不再产生这部分费用。",
-    },
-    {
-      label: "搜索范围",
-      content:
-        plan.capabilities.content_plane === "raw"
-          ? "切换后搜索原始对话。"
-          : plan.capabilities.graph_enabled
-            ? "搜索沉淀记忆，并用知识图谱补充关联。"
-            : "搜索沉淀后的记忆。",
-    },
-  ];
-  if (plan.effects.includes("earlier_raw_not_extracted"))
-    rows.push({
-      label: "已有数据",
-      content: "已经处理完的旧对话不会补做；原始对话全部保留。",
-    });
-  if (plan.effects.includes("higher_mode_memories_hidden"))
-    rows.push({
-      label: "已有数据",
-      content:
-        plan.effective_target === "pro"
-          ? "普通沉淀记忆仍可使用；深度记忆新增的更高层记忆和图谱数据继续保留，但在智能记忆下不显示、不参与召回。原始对话不会删除。"
-          : "已有记忆继续保留，但在基础记忆下不显示、不参与召回；原始对话不会删除。",
-    });
-  if (plan.effects.includes("existing_memories_added_to_graph"))
-    rows.push({
-      label: "知识图谱",
-      content: "已有记忆会在后台加入知识图谱，期间仍可使用。",
-    });
-  if (plan.effects.includes("evolve_stopped"))
-    rows.push({
-      label: "每天自动整合",
-      content: "每天自动整合会停止，已经生成的数据不会删除。",
-    });
-  if (plan.capabilities.evolve_available)
-    rows.push({
-      label: "切换后",
-      content: "可设置每天自动整合时间，也可以随时立即整合一次。",
-    });
-  return rows;
-}
-
-const BLOCKER_COPY: Record<MemoryModePlan["blockers"][number], string> = {
-  active_model_required: "使用 pro 或 ultra 前需要先配置并启用生成模型。",
-  embedding_maintenance_in_progress:
-    "正在检查或切换向量模型，完成后才能切换记忆模式。",
-  memory_lifecycle_busy: "记忆维护正在进行，完成后才能切换模式。",
-  graph_store_unavailable: "当前安装缺少知识图谱组件，无法开启 ultra。",
-};
+import { UltraEvolveScheduleFields } from "./UltraEvolveScheduleFields";
 
 export function MemoryModeSettings({
   hasActiveModel,
@@ -143,65 +58,9 @@ export function MemoryModeSettings({
   const [readFailed, setReadFailed] = useState(false);
   const [run, setRun] = useState<EvolveRunReceipt | null>(null);
   const refreshVersion = useRef(0);
-  const dialog = useRef<HTMLElement>(null);
   const dialogOpener = useRef<HTMLElement | null>(null);
   const focusEvolveWhenReady = useRef(false);
   const focusModeWhenReady = useRef<MemoryPipelineMode | null>(null);
-  const busyRef = useRef(false);
-  busyRef.current = busy;
-
-  useEffect(() => {
-    if (!pendingMode || !dialog.current) return;
-    const panel = dialog.current;
-    const inertSiblings = new Map<HTMLElement, boolean>();
-    let branch: HTMLElement = panel.parentElement ?? panel;
-    while (branch.parentElement) {
-      for (const sibling of branch.parentElement.children) {
-        if (!(sibling instanceof HTMLElement) || sibling === branch) continue;
-        inertSiblings.set(sibling, sibling.inert);
-        sibling.inert = true;
-      }
-      branch = branch.parentElement;
-      if (branch === document.body) break;
-    }
-    const controls = () =>
-      Array.from(panel.querySelectorAll<HTMLElement>("button:not(:disabled)"));
-    controls()[0]?.focus();
-    const handleKey = (event: KeyboardEvent) => {
-      if (event.key === "Escape" && !busyRef.current) {
-        event.preventDefault();
-        setPendingPlan(null);
-        setPendingMode(null);
-        return;
-      }
-      if (event.key !== "Tab") return;
-      const items = controls();
-      const first = items[0];
-      const last = items.at(-1);
-      if (!first || !last) {
-        event.preventDefault();
-        panel.focus();
-        return;
-      }
-      if (event.shiftKey && document.activeElement === first) {
-        event.preventDefault();
-        last.focus();
-      } else if (!event.shiftKey && document.activeElement === last) {
-        event.preventDefault();
-        first.focus();
-      }
-    };
-    panel.addEventListener("keydown", handleKey);
-    return () => {
-      panel.removeEventListener("keydown", handleKey);
-      for (const [sibling, wasInert] of inertSiblings) sibling.inert = wasInert;
-      if (dialogOpener.current?.isConnected) dialogOpener.current.focus();
-    };
-  }, [pendingMode]);
-
-  useEffect(() => {
-    if (pendingMode && busy) dialog.current?.focus();
-  }, [busy, pendingMode]);
 
   useEffect(() => {
     if (!focusEvolveWhenReady.current || pendingMode || state?.mode !== "ultra")
@@ -374,16 +233,11 @@ export function MemoryModeSettings({
           <p>{text("模式决定新对话如何保存，以及记忆页面展示什么。")}</p>
         </div>
       </div>
-      <MemoryModeChoiceList
+      <MemoryModeCards
         aria-label={text("当前模式")}
         aria-busy={state === null}
-        modes={(["lite", "pro", "ultra"] as const).map((mode) => ({
-          mode,
-          title: text(MODE_COPY[mode].title),
-          description: text(MODE_COPY[mode].description),
-        }))}
         current={state?.mode}
-        selected={state?.mode ?? null}
+        value={state?.mode ?? null}
         currentBadge={text("当前模式")}
         disabled={(mode) =>
           !state ||
@@ -393,6 +247,50 @@ export function MemoryModeSettings({
           (mode !== "lite" && !modelStateKnown)
         }
         onChange={(mode, control) => void choose(mode, control)}
+        ultraDetail={
+          state?.mode === "ultra" && schedule ? (
+            <section
+              id={`${id}-evolve`}
+              className="r6-evolve-settings r6-evolve-settings--in-card"
+              aria-labelledby={`${id}-evolve-title`}
+              tabIndex={-1}
+            >
+              <UltraEvolveScheduleFields
+                schedule={schedule}
+                headingId={`${id}-evolve-title`}
+                disabled={busy || maintenance}
+                onEnabledChange={(enabled) => void changeSchedule({ enabled })}
+                onTimeChange={(time) => changeSchedule({ time })}
+              />
+              <div className="r6-evolve-setting r6-evolve-setting--manual">
+                <div className="r6-evolve-setting-copy">
+                  <h3>{text("立即整合一次")}</h3>
+                  <p>
+                    {text("只运行这一次，不改变每天的计划。")}
+                    {" · "}
+                    {text(
+                      run?.state === "running"
+                        ? "正在整合记忆…"
+                        : last?.last_run_at
+                          ? text("上次整合：{time}").replace(
+                              "{time}",
+                              new Date(last.last_run_at).toLocaleString(locale),
+                            )
+                          : "尚未整合",
+                    )}
+                  </p>
+                </div>
+                <R6Button
+                  pending={run?.state === "running"}
+                  disabled={busy || lifecycleBusy}
+                  onClick={() => void evolveNow()}
+                >
+                  {text("立即整合")}
+                </R6Button>
+              </div>
+            </section>
+          ) : null
+        }
       />
       {state?.forced_by_env ? (
         <p className="r6-settings-note" role="status">
@@ -422,139 +320,19 @@ export function MemoryModeSettings({
         )
       ) : null}
 
-      {state?.mode === "ultra" && schedule ? (
-        <section
-          id={`${id}-evolve`}
-          className="r6-evolve-settings"
-          aria-labelledby={`${id}-evolve-title`}
-          tabIndex={-1}
-        >
-          <div className="r6-evolve-heading">
-            <h3 id={`${id}-evolve-title`}>{text("记忆整合（Evolve）")}</h3>
-            <p>{text("定期重新整理已有记忆，补充更稳定的关联和结论。")}</p>
-          </div>
-          <div className="r6-evolve-setting">
-            <div className="r6-evolve-setting-copy">
-              <h3>{text("每天自动整合")}</h3>
-              <p>
-                {text(
-                  schedule.enabled
-                    ? "每天 {time} 左右自动整合，使用这台设备的本地时间；休眠错过后会补跑。"
-                    : "已关闭。重新开启后仍按 {time} 运行；已生成的结果会保留。",
-                ).replace("{time}", schedule.time)}
-              </p>
-            </div>
-            <R6Switch
-              label={text("每天自动整合")}
-              checked={schedule.enabled}
-              disabled={busy || maintenance}
-              onCheckedChange={(enabled) => void changeSchedule({ enabled })}
-            />
-            {schedule.enabled ? (
-              <div className="r6-evolve-time">
-                <div>
-                  <label htmlFor={`${id}-evolve-time`}>
-                    {text("执行时间")}
-                  </label>
-                  <p>{text("使用这台设备的本地时间。")}</p>
-                </div>
-                <TimePicker
-                  id={`${id}-evolve-time`}
-                  label={text("执行时间")}
-                  value={schedule.time}
-                  disabled={busy || maintenance}
-                  onChange={(time) => changeSchedule({ time })}
-                />
-              </div>
-            ) : null}
-          </div>
-          <div className="r6-evolve-setting r6-evolve-setting--manual">
-            <div className="r6-evolve-setting-copy">
-              <h3>{text("立即整合一次")}</h3>
-              <p>
-                {text("只运行这一次，不改变每天的计划。")}
-                {" · "}
-                {text(
-                  run?.state === "running"
-                    ? "正在整合记忆…"
-                    : last?.last_run_at
-                      ? text("上次整合：{time}").replace(
-                          "{time}",
-                          new Date(last.last_run_at).toLocaleString(locale),
-                        )
-                      : "尚未整合",
-                )}
-              </p>
-            </div>
-            <R6Button
-              pending={run?.state === "running"}
-              disabled={busy || lifecycleBusy}
-              onClick={() => void evolveNow()}
-            >
-              {text("立即整合")}
-            </R6Button>
-          </div>
-        </section>
-      ) : null}
-
-      {pendingMode ? (
-        <div className="r6-settings-dialog-layer" role="presentation">
-          <section
-            ref={dialog}
-            className="r6-settings-dialog r6-mode-confirm-dialog"
-            role="dialog"
-            aria-modal="true"
-            aria-labelledby="memory-mode-confirm-title"
-            tabIndex={-1}
-          >
-            <h2 id="memory-mode-confirm-title">
-              {text("切换到 {mode}？").replace(
-                "{mode}",
-                text(MODE_COPY[pendingMode].title),
-              )}
-            </h2>
-            <dl className="r6-mode-confirm-effects">
-              {(pendingPlan ? planRows(pendingPlan) : []).map((row) => (
-                <div key={`${row.label}:${row.content}`}>
-                  <dt>{text(row.label)}</dt>
-                  <dd>{text(row.content)}</dd>
-                </div>
-              ))}
-            </dl>
-            {(pendingPlan?.blockers ?? []).map((blocker) => (
-              <p className="r6-settings-error" role="alert" key={blocker}>
-                {text(BLOCKER_COPY[blocker])}
-              </p>
-            ))}
-            {error ? (
-              <p className="r6-settings-error" role="alert">
-                {text(error)}
-              </p>
-            ) : null}
-            <footer>
-              <R6Button
-                disabled={busy}
-                onClick={() => {
-                  setPendingPlan(null);
-                  setPendingMode(null);
-                }}
-              >
-                {text("取消")}
-              </R6Button>
-              <R6Button
-                variant="primary"
-                pending={busy}
-                disabled={Boolean(pendingPlan?.blockers.length)}
-                onClick={() => void commitMode()}
-              >
-                {text("切换到 {mode}").replace(
-                  "{mode}",
-                  text(MODE_COPY[pendingMode].title),
-                )}
-              </R6Button>
-            </footer>
-          </section>
-        </div>
+      {pendingMode && pendingPlan ? (
+        <MemoryModeConfirmDialog
+          mode={pendingMode}
+          plan={pendingPlan}
+          busy={busy}
+          error={error}
+          opener={dialogOpener.current}
+          onCancel={() => {
+            setPendingPlan(null);
+            setPendingMode(null);
+          }}
+          onConfirm={() => void commitMode()}
+        />
       ) : null}
     </section>
   );

memhub/apps/web/src/MemorySpace.r6.test.tsx

@@ -77,6 +77,7 @@ const { reads } = vi.hoisted(() => ({
     processing: vi.fn(),
     profiles: vi.fn(),
     raw: vi.fn(),
+    rawGraph: vi.fn(),
     rawSearch: vi.fn(),
   },
 }));
@@ -87,6 +88,7 @@ vi.mock("./api", async (importOriginal) => ({
   getMemoryProcessing: reads.processing,
   getModelProfiles: reads.profiles,
   getSdkRaw: reads.raw,
+  getSdkRawGraph: reads.rawGraph,
   searchSdkRaw: reads.rawSearch,
 }));
 vi.mock("./GraphWidthPrompt", () => ({ GraphWidthPrompt: () => null }));
@@ -119,6 +121,9 @@ vi.mock("./MemoryAddComposer", () => ({
 vi.mock("./MemoryGraph3D", () => ({
   MemoryGraph3D: () => <div data-testid="graph-owner" />,
 }));
+vi.mock("./RawConversationGraph3D", () => ({
+  RawConversationGraph3D: () => <div data-testid="graph-owner" />,
+}));
 afterEach(() => {
   cleanup();
   vi.useRealTimers();
@@ -208,6 +213,25 @@ function setup() {
     limit: 100,
     offset: 0,
   });
+  reads.rawGraph.mockResolvedValue({
+    user_id: "local",
+    items: [
+      {
+        turn_id: "raw-1",
+        raw_id: "raw-1",
+        label: "原始对话内容",
+        source: "cursor",
+        session_id: "session-1",
+        memory_at: null,
+        gmt_created: 1_761_000_000,
+      },
+    ],
+    total: 1,
+    limit: 500,
+    offset: 0,
+    has_more: false,
+    snapshot_id: "snapshot-1",
+  });
   reads.rawSearch.mockResolvedValue([]);
 }
 
@@ -289,6 +313,11 @@ it("shows raw conversations instead of advanced memory in lite", async () => {
   render(<MemorySpace simplified />);
 
   expect(await screen.findAllByText("原始对话内容")).toHaveLength(2);
+  expect(screen.getByText("1 条原始对话")).toBeTruthy();
+  expect(screen.queryByText("找到 1 条")).toBeNull();
+  expect(
+    screen.getByRole("heading", { level: 2, name: "来源归属" }),
+  ).toBeTruthy();
   expect(
     document.querySelector(".core-memory-map")?.hasAttribute("hidden"),
   ).toBe(false);
@@ -306,7 +335,7 @@ it("shows raw conversations instead of advanced memory in lite", async () => {
     expect.objectContaining({
       source: undefined,
       offset: 0,
-      limit: 20,
+      limit: 50,
       signal: expect.any(AbortSignal),
     }),
   );
@@ -316,13 +345,103 @@ it("shows raw conversations instead of advanced memory in lite", async () => {
   expect(document.querySelector(".memory-mode-notice")).toBeNull();
 });
 
+it("loads the complete raw graph independently and reports its exact total", async () => {
+  setup();
+  reads.processing.mockResolvedValue(modeProcessing("lite"));
+  reads.rawGraph.mockImplementation(async ({ offset = 0 }) => {
+    const total = 1_600;
+    const count = Math.min(500, total - offset);
+    return {
+      user_id: "local",
+      items: Array.from({ length: count }, (_, index) => {
+        const absolute = offset + index;
+        return {
+          turn_id: `turn-${absolute}`,
+          raw_id: `raw-${absolute}`,
+          label: `原始会话 ${absolute}`,
+          source: "cursor",
+          session_id: `session-${absolute}`,
+          memory_at: null,
+          gmt_created: 1_761_000_000,
+        };
+      }),
+      total,
+      limit: 500,
+      offset,
+      has_more: offset + count < total,
+      snapshot_id: "snapshot-1600",
+    };
+  });
+
+  render(<MemorySpace simplified />);
+
+  expect(await screen.findByText("1,600 条原始对话")).toBeTruthy();
+  await waitFor(() => expect(reads.rawGraph).toHaveBeenCalledTimes(4));
+  expect(reads.rawGraph.mock.calls.map(([request]) => request.offset)).toEqual([
+    0, 500, 1_000, 1_500,
+  ]);
+  expect(
+    reads.rawGraph.mock.calls
+      .slice(1)
+      .every(([request]) => request.snapshotId === "snapshot-1600"),
+  ).toBe(true);
+  expect(screen.getByText("1,600 / 1,600")).toBeTruthy();
+});
+
+it("restarts the complete graph when its snapshot expires between pages", async () => {
+  setup();
+  reads.processing.mockResolvedValue(modeProcessing("lite"));
+  const item = {
+    turn_id: "turn-1",
+    raw_id: "raw-1",
+    label: "原始会话",
+    source: "cursor",
+    session_id: "session-1",
+    memory_at: null,
+    gmt_created: 1_761_000_000,
+  };
+  reads.rawGraph
+    .mockResolvedValueOnce({
+      user_id: "local",
+      items: [item],
+      total: 2,
+      limit: 500,
+      offset: 0,
+      has_more: true,
+      snapshot_id: "expired",
+    })
+    .mockRejectedValueOnce(
+      Object.assign(new Error("stale"), {
+        isAxiosError: true,
+        response: { data: { detail: "raw_graph_snapshot_stale" } },
+      }),
+    )
+    .mockResolvedValueOnce({
+      user_id: "local",
+      items: [item],
+      total: 1,
+      limit: 500,
+      offset: 0,
+      has_more: false,
+      snapshot_id: "fresh",
+    });
+
+  render(<MemorySpace simplified />);
+
+  await waitFor(() => expect(reads.rawGraph).toHaveBeenCalledTimes(3));
+  expect(reads.rawGraph.mock.calls[2][0]).toEqual(
+    expect.objectContaining({ offset: 0, snapshotId: undefined }),
+  );
+  expect(screen.getByText("1 / 1")).toBeTruthy();
+});
+
 it("pages and filters the raw conversation data plane in lite", async () => {
   setup();
   reads.processing.mockResolvedValue(modeProcessing("lite"));
   reads.raw.mockImplementation(async (options = {}) => {
-    const offset = "offset" in options ? (options.offset ?? 0) : 0;
+    const cursor = "cursor" in options ? options.cursor : null;
     const source = "source" in options ? options.source : undefined;
-    const rawId = `${source ?? "all"}-${offset}`;
+    const rawId = `${source ?? "all"}-${cursor ? "more" : "first"}`;
     return {
       items: [
         {
@@ -333,14 +452,17 @@ it("pages and filters the raw conversation data plane in lite", async () => {
           source: source ?? "cursor",
           session_id: `session-${rawId}`,
           memory_at: null,
-          gmt_created: 1_761_000_000 - offset,
+          gmt_created: 1_761_000_000,
           custom: {},
           messages: [{ role: "user", content: `原始会话 ${rawId}` }],
         },
       ],
-      total: source ? 1 : 21,
+      total: cursor ? 2 : 1,
       limit: 20,
-      offset,
+      offset: cursor ? 1 : 0,
+      next_cursor: !source && !cursor ? "turn:1:0:1" : null,
+      has_more: !source && !cursor,
+      total_exact: false,
     };
   });
   const user = userEvent.setup();
@@ -359,30 +481,46 @@ it("pages and filters the raw conversation data plane in lite", async () => {
     />,
   );
 
-  expect(await screen.findAllByText("原始会话 all-0")).toHaveLength(2);
-  await user.click(screen.getByRole("button", { name: "下一页记忆" }));
-  expect(await screen.findAllByText("原始会话 all-20")).toHaveLength(2);
+  expect(await screen.findAllByText("原始会话 all-first")).toHaveLength(2);
+  await waitFor(() => expect(reads.rawGraph).toHaveBeenCalledTimes(1));
+  const graphCalls = reads.rawGraph.mock.calls.length;
+  await user.click(screen.getByRole("button", { name: "加载更多" }));
+  expect(await screen.findAllByText("原始会话 all-more")).toHaveLength(1);
+  expect(screen.getAllByText("原始会话 all-first")).toHaveLength(2);
+  expect(reads.rawGraph).toHaveBeenCalledTimes(graphCalls);
   expect(reads.raw).toHaveBeenLastCalledWith(
-    expect.objectContaining({ source: undefined, offset: 20, limit: 20 }),
+    expect.objectContaining({
+      source: undefined,
+      cursor: "turn:1:0:1",
+      paging: "cursor",
+      limit: 50,
+    }),
   );
 
   await user.click(screen.getByRole("combobox", { name: "来源" }));
   await user.click(screen.getByRole("option", { name: "Cursor" }));
-  expect(await screen.findAllByText("原始会话 cursor-0")).toHaveLength(2);
+  expect(await screen.findAllByText("原始会话 cursor-first")).toHaveLength(2);
   expect(reads.raw).toHaveBeenLastCalledWith(
-    expect.objectContaining({ source: "cursor", offset: 0, limit: 20 }),
+    expect.objectContaining({
+      source: "cursor",
+      cursor: null,
+      paging: "cursor",
+      limit: 50,
+    }),
   );
 
   await user.click(screen.getByRole("combobox", { name: "来源" }));
   await user.click(screen.getByRole("option", { name: "手动添加" }));
   expect(
-    await screen.findAllByText("原始会话 one-memory-manual-0"),
+    await screen.findAllByText("原始会话 one-memory-manual-first"),
   ).toHaveLength(2);
   expect(reads.raw).toHaveBeenLastCalledWith(
     expect.objectContaining({
       source: "one-memory-manual",
       offset: 0,
-      limit: 20,
+      limit: 50,
+      paging: "cursor",
+      cursor: null,
     }),
   );
 });
@@ -599,6 +737,15 @@ it("opens a search hit with the complete role transcript", async () => {
       truncated: true,
     },
   ]);
+  reads.rawGraph.mockResolvedValue({
+    user_id: "local",
+    items: [],
+    total: 1_600,
+    limit: 500,
+    offset: 0,
+    has_more: false,
+    snapshot_id: "search-total",
+  });
   const user = userEvent.setup();
   render(<MemorySpace simplified />);
 
@@ -609,6 +756,7 @@ it("opens a search hit with the complete role transcript", async () => {
   await user.click(screen.getByRole("button", { name: "搜索" }));
 
   expect(await screen.findByText("完整问题")).toBeTruthy();
+  expect(screen.getByText("找到 1 条")).toBeTruthy();
   expect(screen.getByText("完整回答")).toBeTruthy();
   expect(
     document.querySelector(".map-dialogue-reading")?.textContent,

memhub/apps/web/src/MemorySpace.sdk-authority.test.tsx

@@ -289,7 +289,7 @@ it("keeps rows, sources, count and graph on the one filtered page", async () =>
   expect(await screen.findByText(/566/)).toBeTruthy();
 });
 
-it("hides the previous source graph until the all-applications graph settles", async () => {
+it("loads each source graph independently from list pagination and search", async () => {
   sdkAuthority();
   render(<MemorySpace simplified active />);
   await waitFor(() =>
@@ -415,17 +415,13 @@ it("hides the previous source graph until the all-applications graph settles", a
   );
   const graphCalls = api.sdkGraph.mock.calls.length;
   fireEvent.click(screen.getByText("search deploy"));
-  await waitFor(() =>
-    expect(screen.getByTestId("map-graph-loading").textContent).toBe("true"),
-  );
-  expect(screen.getByTestId("map-nodes").textContent).toBe("none");
+  expect(screen.getByTestId("map-graph-loading").textContent).toBe("false");
+  expect(screen.getByTestId("map-nodes").textContent).toBe("4");
   expect(screen.getByTestId("map-memories").textContent).toBe("");
   expect(api.sdkGraph).toHaveBeenCalledTimes(graphCalls);
 
   await act(async () => releaseSearch(searchPage));
-  await waitFor(() =>
-    expect(screen.getByTestId("map-graph-loading").textContent).toBe("false"),
-  );
+  expect(screen.getByTestId("map-graph-loading").textContent).toBe("false");
 });
 
 it("opens an SDK memory in place instead of switching away from the map", async () => {

memhub/apps/web/src/MemorySpace.tsx

@@ -9,6 +9,7 @@ import type {
   MemoryLibraryPage,
   MemoryProcessingSummary,
   SdkAskMemory,
+  SdkRawGraphItem,
   SourceResponse,
 } from "@one-memory/contracts";
 import { isMessageKey } from "@one-memory/i18n";
@@ -38,6 +39,7 @@ import {
   getSdkMemoryGraph,
   getSdkMemoryLibrary,
   getSdkRaw,
+  getSdkRawGraph,
   manualExtract,
   searchSdkRaw,
   setExtractionWindow,
@@ -60,9 +62,12 @@ import {
 import {
   type RawMapRecord,
   rawDetail,
+  rawGraphProjection,
+  rawGraphRecord,
   rawLibraryPage,
   rawRecordId,
   rawSearchPage,
+  SDK_RAW_PAGE_SIZE,
 } from "./sdk-raw-map";
 import { sourceNameOr, UNATTRIBUTED_SOURCE_ID } from "./source-label";
 import { traceUiAction } from "./ui-trace";
@@ -123,6 +128,7 @@ export function MemorySpace({
   const selectedRawRef = useRef<RawMapRecord | null>(null);
   selectedRawRef.current = selectedRaw;
   const rawRecords = useRef(new Map<string, RawMapRecord>());
+  const rawRecordsScope = useRef("");
   const [detailLoad, setDetailLoad] = useState<{
     memoryId: string;
     status: "loading" | "failed";
@@ -164,6 +170,8 @@ export function MemorySpace({
       source.grant_revision,
     ]),
   );
+  const sourcesRef = useRef(sources);
+  sourcesRef.current = sources;
   const management = simplified && displayedMode === "library";
   useEffect(() => {
     viewActive.current = active;
@@ -187,6 +195,11 @@ export function MemorySpace({
     status: "ready" | "failed";
     value: MemoryGraphResponse | null;
   } | null>(null);
+  const [sdkGraphProgress, setSdkGraphProgress] = useState<{
+    scope: string;
+    loaded: number;
+    total: number | null;
+  } | null>(null);
   // Bumping this re-reads the page and graph after an edit or a delete.
   const [sdkMapRevision, setSdkMapRevision] = useState(0);
   const bumpSdkMap = useCallback(() => setSdkMapRevision((v) => v + 1), []);
@@ -209,6 +222,7 @@ export function MemorySpace({
   const [sdkLibraryQuery, setSdkLibraryQuery] = useState("");
   const [sdkLibrarySource, setSdkLibrarySource] = useState("");
   const [sdkLibraryOffset, setSdkLibraryOffset] = useState(0);
+  const [sdkRawCursor, setSdkRawCursor] = useState<string | null>(null);
   const [processing, setProcessing] = useState<MemoryProcessingSummary | null>(
     null,
   );
@@ -226,6 +240,10 @@ export function MemorySpace({
         evolve_available: pipelineMode === "ultra",
       }
     : null;
+  const refreshSdkMap = useCallback(() => {
+    if (lite) setSdkRawCursor(null);
+    bumpSdkMap();
+  }, [bumpSdkMap, lite]);
   const requestedQuery = sdkLibraryQuery.trim();
   const sdkPageSettled =
     sdkLibrary.settledMode === pipelineMode &&
@@ -233,18 +251,21 @@ export function MemorySpace({
     sdkLibrary.settledQuery.trim() === requestedQuery &&
     sdkLibrary.page?.offset === sdkLibraryOffset;
   const sdkPage = sdkPageSettled ? sdkLibrary.page : null;
-  const sdkRequestedScope = JSON.stringify([
+  const sdkGraphRequestedScope = JSON.stringify([
     pipelineMode,
-    sdkLibraryQuery.trim(),
     sdkLibrarySource,
   ]);
-  const sdkGraphSettled = sdkGraph?.scope === sdkRequestedScope;
+  const sdkGraphSettled = sdkGraph?.scope === sdkGraphRequestedScope;
   const visibleSdkGraph =
-    sdkGraph?.scope === sdkRequestedScope && sdkGraph.status === "ready"
+    sdkGraph?.scope === sdkGraphRequestedScope && sdkGraph.status === "ready"
       ? sdkGraph.value
       : null;
   const sdkGraphFailed =
-    sdkGraph?.scope === sdkRequestedScope && sdkGraph.status === "failed";
+    sdkGraph?.scope === sdkGraphRequestedScope && sdkGraph.status === "failed";
+  const visibleGraphProgress =
+    sdkGraphProgress?.scope === sdkGraphRequestedScope
+      ? sdkGraphProgress
+      : null;
   // A keyword search pages through one server-side result window. The id is
   // kept for the query and source it was searched with; a new query or
   // source starts without one, so the server searches afresh.
@@ -276,7 +297,10 @@ export function MemorySpace({
       if (first) setSdkLibrary((current) => ({ ...current, loading: true }));
       try {
         const rememberRaw = (items: RawMapRecord[]) => {
-          const next = new Map<string, RawMapRecord>();
+          const next =
+            sdkRawCursor && rawRecordsScope.current === windowKey
+              ? new Map(rawRecords.current)
+              : new Map<string, RawMapRecord>();
           if (selectedRawRef.current)
             next.set(
               rawRecordId(selectedRawRef.current),
@@ -284,60 +308,39 @@ export function MemorySpace({
             );
           for (const item of items) next.set(rawRecordId(item), item);
           rawRecords.current = next;
+          rawRecordsScope.current = windowKey;
         };
-        const [page, graph] = lite
-          ? await Promise.all([
-              query
-                ? searchSdkRaw(query, {
-                    source,
-                    signal: request.signal,
-                  }).then((items) => {
-                    rememberRaw(items);
-                    return rawSearchPage(items);
-                  })
-                : getSdkRaw({
-                    source,
-                    offset: sdkLibraryOffset,
-                    limit: SDK_MEMORY_PAGE_SIZE,
-                    signal: request.signal,
-                  }).then((rawPage) => {
-                    rememberRaw(rawPage.items);
-                    return rawLibraryPage(rawPage);
-                  }),
-              Promise.resolve({
-                status: "ready" as const,
-                value: null,
-              }),
-            ])
-          : await Promise.all([
-              getSdkMemoryLibrary(
-                {
-                  statuses: ["active"],
-                  source,
-                  query,
-                  offset: sdkLibraryOffset,
-                  limit: SDK_MEMORY_PAGE_SIZE,
-                  windowId: query ? sdkSearchWindow.current.id : null,
-                },
-                request.signal,
-              ).then(sdkLibraryPage),
-              query
-                ? Promise.resolve({
-                    status: "ready" as const,
-                    value: null,
-                  })
-                : getSdkMemoryGraph(
-                    {
-                      source,
-                      offset: 0,
-                      limit: 300,
-                    },
-                    request.signal,
-                  ).then(
-                    (value) => ({ status: "ready" as const, value }),
-                    () => ({ status: "failed" as const, value: null }),
-                  ),
-            ]);
+        const page = lite
+          ? query
+            ? await searchSdkRaw(query, {
+                source,
+                signal: request.signal,
+              }).then((items) => {
+                rememberRaw(items);
+                return rawSearchPage(items);
+              })
+            : await getSdkRaw({
+                source,
+                offset: 0,
+                limit: SDK_RAW_PAGE_SIZE,
+                paging: "cursor",
+                cursor: sdkRawCursor,
+                signal: request.signal,
+              }).then((rawPage) => {
+                rememberRaw(rawPage.items);
+                return rawLibraryPage(rawPage);
+              })
+          : await getSdkMemoryLibrary(
+              {
+                statuses: ["active"],
+                source,
+                query,
+                offset: sdkLibraryOffset,
+                limit: SDK_MEMORY_PAGE_SIZE,
+                windowId: query ? sdkSearchWindow.current.id : null,
+              },
+              request.signal,
+            ).then(sdkLibraryPage);
         if (cancelled) return;
         if (!lite && sdkSearchWindow.current.key === windowKey)
           sdkSearchWindow.current = {
@@ -346,17 +349,63 @@ export function MemorySpace({
           };
         // The window expired: the server searched again and answered page 1.
         if (page.window_reset && sdkLibraryOffset !== 0) setSdkLibraryOffset(0);
-        setSdkLibrary({
-          page,
-          loading: false,
-          failed: false,
-          settledSource: sdkLibrarySource,
-          settledQuery: sdkLibraryQuery,
-          settledMode: pipelineMode,
+        setSdkLibrary((current) => {
+          const currentPage = current.page;
+          const append =
+            lite &&
+            sdkRawCursor !== null &&
+            currentPage !== null &&
+            current.settledSource === sdkLibrarySource &&
+            current.settledQuery === sdkLibraryQuery &&
+            current.settledMode === pipelineMode;
+          if (!append)
+            return {
+              page,
+              loading: false,
+              failed: false,
+              settledSource: sdkLibrarySource,
+              settledQuery: sdkLibraryQuery,
+              settledMode: pipelineMode,
+            };
+          const items = [...currentPage.items];
+          const known = new Set(items.map((item) => item.memory_id));
+          for (const item of page.items)
+            if (!known.has(item.memory_id)) {
+              known.add(item.memory_id);
+              items.push(item);
+            }
+          return {
+            page: {
+              ...page,
+              items,
+              total: items.length + (page.has_more ? 1 : 0),
+              offset: 0,
+              source_ids_by_memory: {
+                ...currentPage.source_ids_by_memory,
+                ...page.source_ids_by_memory,
+              },
+              source_time_by_memory: {
+                ...currentPage.source_time_by_memory,
+                ...page.source_time_by_memory,
+              },
+            },
+            loading: false,
+            failed: false,
+            settledSource: sdkLibrarySource,
+            settledQuery: sdkLibraryQuery,
+            settledMode: pipelineMode,
+          };
         });
-        setSdkGraph({ scope: windowKey, ...graph });
-      } catch {
+      } catch (reason) {
         if (cancelled || request.signal.aborted) return;
+        if (
+          lite &&
+          sdkRawCursor !== null &&
+          apiErrorCode(reason) === "raw_cursor_stale"
+        ) {
+          setSdkRawCursor(null);
+          return;
+        }
         setSdkLibrary((current) => ({
           ...current,
           loading: false,
@@ -365,10 +414,13 @@ export function MemorySpace({
       }
     };
     void read(true);
-    const timer = setInterval(() => void read(false), 30_000);
+    const timer =
+      lite && sdkRawCursor !== null
+        ? undefined
+        : setInterval(() => void read(false), 30_000);
     return () => {
       cancelled = true;
-      clearInterval(timer);
+      if (timer !== undefined) clearInterval(timer);
       controller?.abort();
     };
   }, [
@@ -377,9 +429,118 @@ export function MemorySpace({
     sdkLibraryOffset,
     sdkLibraryQuery,
     sdkLibrarySource,
+    sdkRawCursor,
     lite,
     pipelineMode,
   ]);
+  const rawGraphRecords = useRef(new Map<string, RawMapRecord>());
+  useEffect(() => {
+    if (!sdkMapVisible) return;
+    void sdkMapRevision;
+    void sourceKey;
+    const scope = sdkGraphRequestedScope;
+    const source = sdkLibrarySource || undefined;
+    const request = new AbortController();
+    let cancelled = false;
+    let reading = false;
+    rawGraphRecords.current.clear();
+    setSdkGraphProgress({ scope, loaded: 0, total: null });
+    const readGraph = async () => {
+      if (reading) return;
+      reading = true;
+      try {
+        if (!lite) {
+          const value = await getSdkMemoryGraph(
+            { source, offset: 0, limit: 300 },
+            request.signal,
+          );
+          if (cancelled) return;
+          setSdkGraph({ scope, status: "ready", value });
+          setSdkGraphProgress({
+            scope,
+            loaded: value.projected_memories,
+            total: value.total_memories,
+          });
+          return;
+        }
+
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+          const items: SdkRawGraphItem[] = [];
+          let offset = 0;
+          let total = 0;
+          let snapshotId: string | undefined;
+          rawGraphRecords.current.clear();
+          try {
+            while (!cancelled) {
+              const page = await getSdkRawGraph({
+                source,
+                offset,
+                limit: 500,
+                snapshotId,
+                signal: request.signal,
+              });
+              if (cancelled) return;
+              snapshotId = page.snapshot_id;
+              total = page.total;
+              items.push(...page.items);
+              for (const item of page.items) {
+                const record = rawGraphRecord(item);
+                rawGraphRecords.current.set(rawRecordId(record), record);
+              }
+              setSdkGraphProgress({ scope, loaded: items.length, total });
+              if (!page.has_more || page.items.length === 0) break;
+              offset += page.items.length;
+              await new Promise<void>((resolve) => setTimeout(resolve, 0));
+            }
+          } catch (reason) {
+            if (
+              attempt === 0 &&
+              apiErrorCode(reason) === "raw_graph_snapshot_stale"
+            )
+              continue;
+            throw reason;
+          }
+          if (cancelled) return;
+          setSdkGraph({
+            scope,
+            status: "ready",
+            value: rawGraphProjection(items, total, sourcesRef.current),
+          });
+          break;
+        }
+      } catch {
+        if (cancelled || request.signal.aborted) return;
+        setSdkGraph({ scope, status: "failed", value: null });
+      } finally {
+        reading = false;
+      }
+    };
+    void readGraph();
+    const timer = setInterval(() => void readGraph(), 30_000);
+    return () => {
+      cancelled = true;
+      clearInterval(timer);
+      request.abort();
+    };
+  }, [
+    lite,
+    sdkGraphRequestedScope,
+    sdkLibrarySource,
+    sdkMapRevision,
+    sdkMapVisible,
+    sourceKey,
+  ]);
+  const displayedSdkPage =
+    lite &&
+    !sdkLibraryQuery.trim() &&
+    sdkPage &&
+    visibleGraphProgress?.total != null
+      ? {
+          ...sdkPage,
+          total: visibleGraphProgress.total,
+          total_exact: true,
+        }
+      : sdkPage;
   const sdkFilterLabel = [
     sdkLibrary.settledSource
       ? `${t("memory:来源")} ${
@@ -509,10 +670,13 @@ export function MemorySpace({
   }, [active, onArrivalChange]);
   const requestIds = useRef(new Map<string, string>());
   const detailEpoch = useRef(0);
+  const rawDetailController = useRef<AbortController | null>(null);
   const answerEpoch = useRef(0);
   const answerMemories = useRef<AskMemory[]>([]);
   const closeDetail = useCallback(() => {
     detailEpoch.current++;
+    rawDetailController.current?.abort();
+    rawDetailController.current = null;
     setDetail(null);
     setSelectedRaw(null);
     setDetailLoad(null);
@@ -525,6 +689,7 @@ export function MemorySpace({
     rawRecords.current.clear();
     sdkSearchWindow.current = { key: "", id: null };
     setSdkLibraryOffset(0);
+    setSdkRawCursor(null);
     setSdkLibraryQuery("");
     setSdkGraph(null);
     setSdkLibrary((current) => ({
@@ -586,6 +751,8 @@ export function MemorySpace({
       cancelled = true;
       stopProcessing();
       detailEpoch.current++;
+      rawDetailController.current?.abort();
+      rawDetailController.current = null;
       answerEpoch.current++;
       deleteAnswer.current?.(false);
       deleteAnswer.current = null;
@@ -697,11 +864,15 @@ export function MemorySpace({
   async function open(memoryId: string) {
     if (simplified && (!viewActive.current || stale.current)) return;
     const epoch = ++detailEpoch.current;
+    rawDetailController.current?.abort();
+    rawDetailController.current = null;
     setError(null);
     setDetail(null);
     setSelectedRaw(null);
     if (lite) {
-      let record = rawRecords.current.get(memoryId);
+      let record =
+        rawRecords.current.get(memoryId) ??
+        rawGraphRecords.current.get(memoryId);
       if (!record) {
         setDetailLoad({
           memoryId,
@@ -712,6 +883,8 @@ export function MemorySpace({
       }
       if ("kind" in record) {
         setDetailLoad({ memoryId, status: "loading" });
+        const request = new AbortController();
+        rawDetailController.current = request;
         try {
           let offset = 0;
           while (true) {
@@ -720,6 +893,7 @@ export function MemorySpace({
               sessionId: record.session_id || undefined,
               offset,
               limit: 500,
+              signal: request.signal,
             });
             const full = page.items.find(
               (item) => rawRecordId(item) === memoryId,
@@ -734,15 +908,18 @@ export function MemorySpace({
               throw new Error("raw_not_found");
           }
         } catch {
-          if (epoch === detailEpoch.current)
+          if (epoch === detailEpoch.current) {
+            rawDetailController.current = null;
             setDetailLoad({
               memoryId,
               status: "failed",
               error: t("sdk.raw.loadFailed"),
             });
+          }
           return;
         }
         if (epoch !== detailEpoch.current) return;
+        rawDetailController.current = null;
       }
       setSelectedRaw(record);
       setDetail(rawDetail(record));
@@ -804,7 +981,7 @@ export function MemorySpace({
       );
       trace.done("succeeded");
       closeDetail();
-      bumpSdkMap();
+      refreshSdkMap();
     } catch (reason) {
       trace.done(writeTraceStatus(reason), {
         reason: "memory_action_failed",
@@ -833,7 +1010,7 @@ export function MemorySpace({
       trace.done("succeeded");
       setDetail(sdkDetail(saved));
       setDraft(sdkEditableText(saved));
-      bumpSdkMap();
+      refreshSdkMap();
     } catch (reason) {
       trace.done(writeTraceStatus(reason), {
         reason: isDefiniteRefusal(reason)
@@ -897,11 +1074,12 @@ export function MemorySpace({
               ? pipelineMode === null
                 ? t("memory:记忆暂时无法读取")
                 : lite
-                  ? sdkPage
-                    ? `${t("memory:原始对话")} · ${tn(
-                        "sdk.raw.found",
-                        sdkPage.total,
-                      )}`
+                  ? displayedSdkPage
+                    ? displayedSdkPage.total_exact === false
+                      ? t("memory:原始对话")
+                      : sdkLibrary.settledQuery.trim()
+                        ? tn("sdk.raw.found", displayedSdkPage.total)
+                        : tn("sdk.raw.total", displayedSdkPage.total)
                     : sdkLibrary.failed
                       ? null
                       : t("memory:正在读取…")
@@ -934,7 +1112,7 @@ export function MemorySpace({
           onSaved={() => {
             // A finished addition is new page content: re-read now rather than
             // leave it for the next poll.
-            bumpSdkMap();
+            refreshSdkMap();
           }}
           onOpenMemory={(id) => {
             if (!simplified) setMode("library");
@@ -1192,21 +1370,32 @@ export function MemorySpace({
             ? {
                 query: sdkLibraryQuery,
                 source: sdkLibrarySource,
-                page: sdkPage,
+                page: displayedSdkPage,
                 loading: sdkLibrary.loading,
                 failed: sdkLibrary.failed,
                 graphLoading: !sdkGraphSettled,
                 graphFailed: sdkGraphFailed,
+                graphLoaded: visibleGraphProgress?.loaded,
+                graphTotal: visibleGraphProgress?.total ?? undefined,
                 stale: false,
                 settledSource: sdkLibrary.settledSource,
                 settledQuery: sdkLibrary.settledQuery,
                 requestedOffset: sdkLibraryOffset,
+                cursorPaging: lite && !sdkLibraryQuery.trim(),
+                hasMore: !!sdkPage?.has_more && !!sdkPage?.next_cursor,
                 unattributedSource: UNATTRIBUTED_SOURCE_ID,
                 onQuery: setSdkLibraryQuery,
                 onSource: setSdkLibrarySource,
-                resetPage: () => setSdkLibraryOffset(0),
+                resetPage: () => {
+                  setSdkLibraryOffset(0);
+                  setSdkRawCursor(null);
+                },
                 onPage: (offset) => setSdkLibraryOffset(offset),
-                onRetry: bumpSdkMap,
+                onMore: () => {
+                  if (sdkPage?.next_cursor)
+                    setSdkRawCursor(sdkPage.next_cursor);
+                },
+                onRetry: refreshSdkMap,
               }
             : undefined
         }
@@ -1215,7 +1404,7 @@ export function MemorySpace({
           displayedMode !== "map" ||
           (simplified && pipelineMode === null)
         }
-        memories={sdkPage?.items ?? []}
+        memories={displayedSdkPage?.items ?? []}
         graph={visibleSdkGraph}
         sources={sources}
         processing={processing}

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

@@ -1482,7 +1482,12 @@ describe("ModelSettings", () => {
       ...profile,
       profile_id: "created",
       revision: 1,
-      capabilities,
+      capabilities: {
+        ...capabilities,
+        endpoint_reachable: false,
+        model_available: false,
+        embedding_available: false,
+      },
     };
     profiles = [];
     create.mockImplementation(async () => {
@@ -1491,11 +1496,17 @@ describe("ModelSettings", () => {
     });
     probeProfile.mockResolvedValue({
       profile_id: created.profile_id,
-      profile_revision: created.revision,
+      input_profile_revision: created.revision,
+      profile_revision: 2,
       stages: [],
       capabilities,
     });
-    activate.mockResolvedValue({ ...created, is_active: true });
+    activate.mockResolvedValue({
+      ...created,
+      revision: 2,
+      capabilities,
+      is_active: true,
+    });
     render(<ModelSettings compactSingle onSetupComplete={onSetupComplete} />);
 
     await user.type(screen.getByLabelText("配置名称"), "Current model");
@@ -1504,10 +1515,7 @@ describe("ModelSettings", () => {
     await user.click(screen.getByRole("button", { name: "测试并完成配置" }));
 
     await waitFor(() => expect(onSetupComplete).toHaveBeenCalledOnce());
-    expect(planActivation).toHaveBeenCalledWith(
-      created.profile_id,
-      created.revision,
-    );
+    expect(planActivation).toHaveBeenCalledWith(created.profile_id, 2);
     expect(activate).toHaveBeenCalledWith(created.profile_id);
   });
 

memhub/apps/web/src/ModelSettings.tsx

@@ -27,6 +27,7 @@ import {
   presetForGeneration,
   validateGenerationModel,
 } from "./GenerationModelPrimitives";
+import { modelProfileReady, profileFromProbe } from "./model-profile-readiness";
 import { OptionMenu } from "./OptionMenu";
 import { useOnboardingTranslation } from "./onboarding-language";
 import { PROVIDER_PRESETS } from "./provider-presets";
@@ -174,27 +175,6 @@ function validEndpoint(value: string): boolean {
   }
 }
 
-function ready(
-  profile: ModelProfile,
-  probe: ModelProbeResult | null = null,
-  error: string | null = null,
-): boolean {
-  return (
-    !error &&
-    (!probe ||
-      (probe.profile_id === profile.profile_id &&
-        probe.profile_revision === profile.revision &&
-        probe.capabilities.endpoint_reachable &&
-        probe.capabilities.model_available &&
-        probe.capabilities.embedding_available)) &&
-    profile.credential_state !== "unavailable" &&
-    !(profile.has_configured_api_key && !profile.has_api_key) &&
-    profile.capabilities.endpoint_reachable &&
-    profile.capabilities.model_available &&
-    profile.capabilities.embedding_available
-  );
-}
-
 function endpointLabel(value: string | null): string {
   if (!value) return "未提供接口地址";
   try {
@@ -467,7 +447,11 @@ export function ModelSettings({
     technicalTouched.current.clear();
   };
   const isReady = (profile: ModelProfile) =>
-    ready(profile, models.probeFor(profile), models.probeErrorFor(profile));
+    modelProfileReady(
+      profile,
+      models.probeFor(profile),
+      models.probeErrorFor(profile),
+    );
 
   function editProfile(profile: ModelProfile) {
     if (ownerLocked) return;
@@ -626,7 +610,7 @@ export function ModelSettings({
       !active ||
       active.profile_id !== profile.profile_id ||
       !active.is_active ||
-      !ready(active, result)
+      !modelProfileReady(active, result)
     ) {
       setSetupError("配置已保存，尚未确认启用成功。请核对配置后重试。");
       return false;
@@ -640,38 +624,15 @@ export function ModelSettings({
     setSetupPhase("testing");
     const result = await models.probeProfile(profile.profile_id);
     if (!alive.current) return false;
-    if (
-      result &&
-      result.profile_id === profile.profile_id &&
-      result.profile_revision !== profile.revision
-    ) {
-      // A newer revision used to be accepted here, and then activation turned
-      // on whatever the configuration had become. The user is told the
-      // settings they filled in passed, so this hands them a model they never
-      // tested. `ready` below cannot catch it either: by then the probe and
-      // the activated profile are both on the new revision and agree.
-      setSetupError(
-        result.profile_revision > profile.revision
-          ? "这份配置在测试期间被改过，刚才测的是改动后的版本。配置已保存但未启用，请重新测试并启用。"
-          : "测试结果来自这份配置更早的版本。配置已保存但未启用，请重新测试并启用。",
-      );
-      return false;
-    }
-    if (
-      !result ||
-      result.profile_id !== profile.profile_id ||
-      result.profile_revision !== profile.revision ||
-      !result.capabilities.endpoint_reachable ||
-      !result.capabilities.model_available ||
-      !result.capabilities.embedding_available
-    ) {
+    const testedProfile = profileFromProbe(profile, result);
+    if (!testedProfile || !modelProfileReady(testedProfile, result ?? null)) {
       setSetupError(
         "配置已保存，连接测试未通过。请核对配置后重试，历史对话尚未发送。",
       );
       setFields(probeFieldErrors(result));
       return false;
     }
-    return activateWithPlan(profile, result);
+    return activateWithPlan(testedProfile, result ?? null);
   }
 
   async function activateTested(profile: ModelProfile) {
@@ -1940,7 +1901,11 @@ function PresetProfileCard({
           </button>
           <button
             type="button"
-            disabled={busy || !canEnable || !ready(profile, probe, probeError)}
+            disabled={
+              busy ||
+              !canEnable ||
+              !modelProfileReady(profile, probe, probeError)
+            }
             onClick={onActivate}
           >
             {text("设为当前模型")}

memhub/apps/web/src/OnboardingFlow.discovery.test.tsx

@@ -10,13 +10,33 @@ import type { ImportSourcesController } from "./use-import-sources";
 
 vi.mock("./api", () => ({
   completeOnboarding: vi.fn(),
+  getEvolveSchedule: vi.fn().mockResolvedValue({
+    enabled: true,
+    time: "03:00",
+  }),
+  getModelProfiles: vi.fn().mockResolvedValue([]),
+  setEvolveSchedule: vi.fn(),
+  memoryModePlanUnsupported: vi.fn(() => false),
   getMemoryMode: vi.fn().mockResolvedValue({
     mode: "pro",
     configured_mode: "pro",
     explicitly_configured: false,
   }),
   setMemoryMode: vi.fn().mockResolvedValue({ mode: "pro" }),
-  planMemoryMode: vi.fn().mockResolvedValue({ blockers: [] }),
+  planMemoryMode: vi.fn().mockImplementation(async (target) => ({
+    current: "lite",
+    target,
+    effective_target: target,
+    capabilities: {
+      content_plane: target === "lite" ? "raw" : "memory",
+      generation_required: target !== "lite",
+      graph_enabled: target === "ultra",
+      evolve_available: target === "ultra",
+    },
+    effects: [],
+    warnings: [],
+    blockers: target === "lite" ? [] : ["active_model_required"],
+  })),
   putOnboardingProgress: vi.fn().mockResolvedValue({ model_profile_id: null }),
   patchOnboardingProgress: vi.fn().mockResolvedValue({}),
 }));
@@ -141,8 +161,7 @@ it("moves from import to the actual third step without completing onboarding", a
   expect(completeOnboarding).not.toHaveBeenCalled();
   expect(finish).not.toHaveBeenCalled();
   await userEvent.click(screen.getByRole("button", { name: "返回第二步" }));
-  await userEvent.click(screen.getByRole("button", { name: "返回导入" }));
-  expect(screen.getByText("Import accepted")).toBeTruthy();
+  expect(screen.getByRole("heading", { name: "选择记忆模式" })).toBeTruthy();
   expect(completeOnboarding).not.toHaveBeenCalled();
 });
 
@@ -161,7 +180,7 @@ it("lets an empty first-time user enter without granting or importing a source",
       onFinish={finish}
     />,
   );
-  const skip = await screen.findByRole("button", { name: "稍后添加，先进入" });
+  const skip = await screen.findByRole("button", { name: "选择记忆模式" });
   await waitFor(() => expect((skip as HTMLButtonElement).disabled).toBe(false));
   await userEvent.click(skip);
   await userEvent.click(screen.getByRole("radio", { name: /lite/i }));
@@ -184,7 +203,7 @@ it("retains explicit retry or enter when saving the skipped onboarding fails", a
       onFinish={finish}
     />,
   );
-  const skip = await screen.findByRole("button", { name: "稍后添加，先进入" });
+  const skip = await screen.findByRole("button", { name: "选择记忆模式" });
   await waitFor(() => expect((skip as HTMLButtonElement).disabled).toBe(false));
   await userEvent.click(skip);
   await userEvent.click(screen.getByRole("radio", { name: /lite/i }));
@@ -273,7 +292,9 @@ it("freezes the explicitly submitted source list when a later source arrives", a
         resolveRefresh = resolve;
       }),
   );
-  await userEvent.click(screen.getByRole("button", { name: "开始导入" }));
+  await userEvent.click(
+    await screen.findByRole("button", { name: "开始导入" }),
+  );
   const lateSources = [source("workbuddy"), source("codex")];
   rendered.rerender(view({ ...imports, sources: lateSources }));
   expect(checkbox("codex").checked).toBe(false);

memhub/apps/web/src/OnboardingFlow.language.test.tsx

@@ -24,6 +24,12 @@ import type { ImportSourcesController } from "./use-import-sources";
 
 vi.mock("./api", () => ({
   completeOnboarding: vi.fn(),
+  getEvolveSchedule: vi.fn().mockResolvedValue({
+    enabled: true,
+    time: "03:00",
+  }),
+  setEvolveSchedule: vi.fn(),
+  memoryModePlanUnsupported: vi.fn(() => false),
   getModelProfiles: vi.fn(),
   getMemoryMode: vi.fn().mockResolvedValue({
     mode: "pro",
@@ -31,7 +37,20 @@ vi.mock("./api", () => ({
     explicitly_configured: false,
   }),
   setMemoryMode: vi.fn().mockResolvedValue({ mode: "pro" }),
-  planMemoryMode: vi.fn().mockResolvedValue({ blockers: [] }),
+  planMemoryMode: vi.fn().mockResolvedValue({
+    current: "pro",
+    target: "lite",
+    effective_target: "lite",
+    capabilities: {
+      content_plane: "raw",
+      generation_required: false,
+      graph_enabled: false,
+      evolve_available: false,
+    },
+    effects: [],
+    warnings: [],
+    blockers: [],
+  }),
   putOnboardingProgress: vi.fn().mockResolvedValue({ model_profile_id: null }),
   patchOnboardingProgress: vi.fn().mockResolvedValue({}),
 }));
@@ -192,10 +211,10 @@ it("translates discovery, progress and privacy without importing or authorizing
     }),
   ).toBeTruthy();
   expect(
-    screen.getByText(
+    screen.queryByText(
       "Antes de confirmar, solo se comprueba la información de las aplicaciones. No se leen conversaciones ni se instalan conexiones.",
     ),
-  ).toBeTruthy();
+  ).toBeNull();
   expect(
     screen.getByText("/fixture/cursor · Ubicación predeterminada"),
   ).toBeTruthy();
@@ -270,10 +289,10 @@ it("translates import review and preserves independent permission disclosure", a
     }),
   ).toBeTruthy();
   expect(
-    screen.getByText(
+    screen.queryByText(
       "A continuación, elige un modo de memoria. Podrás cambiarlo más adelante en Configuración.",
     ),
-  ).toBeTruthy();
+  ).toBeNull();
   expect(
     screen.getByRole("region", {
       name: "Progreso de importación de las aplicaciones",
@@ -305,16 +324,15 @@ it("uses compact Spanish actions and preserves Chinese copy and permissions", as
     }),
   ).toBeTruthy();
   expect(
-    screen.getByText(/A continuación, elige un modo de memoria/),
-  ).toBeTruthy();
+    screen.queryByText(/A continuación, elige un modo de memoria/),
+  ).toBeNull();
   expect(
     screen.getByText(/Solo para las apps seleccionadas y compatibles/),
   ).toBeTruthy();
-  expect(screen.getByText(/Si una falla, las demás siguen/)).toBeTruthy();
   fireEvent.click(screen.getByText("中文"));
   expect(screen.getByRole("button", { name: "选择记忆模式" })).toBeTruthy();
   expect(navigation.textContent).toContain("连接应用");
-  expect(screen.getByText(/下一步选择记忆模式/)).toBeTruthy();
+  expect(screen.queryByText(/下一步选择记忆模式/)).toBeNull();
   expect(next).not.toHaveBeenCalled();
   expect(draft).not.toHaveBeenCalled();
 });
@@ -406,6 +424,12 @@ it("translates completion recovery live without repeating completion writes", as
     new Error("fixture-offline"),
   );
   const imports = controller();
+  imports.sources = [];
+  vi.mocked(imports.refresh).mockResolvedValue({
+    sources: [],
+    jobs: [],
+    health: null as never,
+  });
   const finish = vi.fn();
   render(
     <LanguageProvider>
@@ -415,11 +439,11 @@ it("translates completion recovery live without repeating completion writes", as
   );
   await waitFor(() =>
     expect(
-      screen.getByRole("button", { name: "Entrar y añadir más tarde" }),
+      screen.getByRole("button", { name: "Elegir el modo de memoria" }),
     ).toHaveProperty("disabled", false),
   );
   fireEvent.click(
-    screen.getByRole("button", { name: "Entrar y añadir más tarde" }),
+    screen.getByRole("button", { name: "Elegir el modo de memoria" }),
   );
   fireEvent.click(screen.getByRole("radio", { name: /lite/i }));
   fireEvent.click(screen.getByRole("button", { name: "Entrar con Lite" }));

memhub/apps/web/src/OnboardingFlow.multisource-recovery.test.tsx

@@ -26,13 +26,32 @@ vi.mock("./api", () => ({
   getImportJobs: vi.fn(),
   connectSources: vi.fn(),
   completeOnboarding: vi.fn(),
+  getEvolveSchedule: vi.fn().mockResolvedValue({
+    enabled: true,
+    time: "03:00",
+  }),
+  setEvolveSchedule: vi.fn(),
+  memoryModePlanUnsupported: vi.fn(() => false),
   getMemoryMode: vi.fn().mockResolvedValue({
     mode: "pro",
     configured_mode: "pro",
     explicitly_configured: false,
   }),
   setMemoryMode: vi.fn().mockResolvedValue({ mode: "pro" }),
-  planMemoryMode: vi.fn().mockResolvedValue({ blockers: [] }),
+  planMemoryMode: vi.fn().mockResolvedValue({
+    current: "pro",
+    target: "lite",
+    effective_target: "lite",
+    capabilities: {
+      content_plane: "raw",
+      generation_required: false,
+      graph_enabled: false,
+      evolve_available: false,
+    },
+    effects: [],
+    warnings: [],
+    blockers: [],
+  }),
   putOnboardingProgress: vi.fn().mockResolvedValue({ model_profile_id: null }),
   patchOnboardingProgress: vi.fn().mockResolvedValue({}),
   getSourceConnection: vi.fn(),
@@ -159,8 +178,23 @@ beforeEach(() => {
   } as never);
   vi.mocked(api.setMemoryMode).mockResolvedValue({ mode: "pro" } as never);
   vi.mocked(api.planMemoryMode).mockResolvedValue({
+    current: "pro",
+    target: "lite",
+    effective_target: "lite",
+    capabilities: {
+      content_plane: "raw",
+      generation_required: false,
+      graph_enabled: false,
+      evolve_available: false,
+    },
+    effects: [],
+    warnings: [],
     blockers: [],
   } as never);
+  vi.mocked(api.getEvolveSchedule).mockResolvedValue({
+    enabled: true,
+    time: "03:00",
+  });
   vi.mocked(api.putOnboardingProgress).mockResolvedValue(state);
   vi.mocked(api.patchOnboardingProgress).mockResolvedValue(state);
   localStorage.clear();
@@ -313,11 +347,11 @@ it("keeps the single-source submit frozen when another source arrives during fin
 it("empty discovery shows zero and allows explicit entry without a connection request", async () => {
   await ready();
   await waitFor(() => expect(count()).toBe("0"));
-  expect(screen.getByRole("button", { name: "开始导入" })).toHaveProperty(
+  expect(screen.getByRole("button", { name: "选择记忆模式" })).toHaveProperty(
     "disabled",
-    true,
+    false,
   );
-  fireEvent.click(screen.getByRole("button", { name: "稍后添加，先进入" }));
+  fireEvent.click(screen.getByRole("button", { name: "选择记忆模式" }));
   fireEvent.click(screen.getByRole("radio", { name: /lite/i }));
   fireEvent.click(screen.getByRole("button", { name: "使用 Lite 进入" }));
   await waitFor(() =>
@@ -363,13 +397,7 @@ it("partial acceptance preserves the successful job and failure through model-st
     "accepted-job:completed",
   );
   fireEvent.click(screen.getByRole("button", { name: "继续配置模型" }));
-  fireEvent.click(await screen.findByRole("button", { name: "返回导入" }));
-  expect(screen.getByLabelText("保留任务").textContent).toBe(
-    "accepted-job:completed",
-  );
-  expect(screen.getByLabelText("失败来源").textContent).toBe("cursor");
   expect(api.completeOnboarding).not.toHaveBeenCalled();
-  fireEvent.click(screen.getByRole("button", { name: "进入应用" }));
   fireEvent.click(screen.getByRole("radio", { name: /lite/i }));
   fireEvent.click(screen.getByRole("button", { name: "使用 Lite 进入" }));
   await waitFor(() =>

memhub/apps/web/src/OnboardingFlow.r6.test.tsx

@@ -15,6 +15,12 @@ import type { ImportSourcesController } from "./use-import-sources";
 
 vi.mock("./api", () => ({
   completeOnboarding: vi.fn(),
+  getEvolveSchedule: vi.fn().mockResolvedValue({
+    enabled: true,
+    time: "03:00",
+  }),
+  setEvolveSchedule: vi.fn(),
+  memoryModePlanUnsupported: vi.fn(() => false),
   getMemoryMode: vi.fn().mockResolvedValue({
     mode: "pro",
     configured_mode: "pro",
@@ -119,7 +125,7 @@ it("renders the final shell, double title, step one, branded rows and exact sour
   expect(
     screen.getByRole("heading", { name: "把熟悉的背景，带到这里" }),
   ).toBeTruthy();
-  expect(screen.getByText("你的记忆，从这里接上")).toBeTruthy();
+  expect(screen.queryByText("你的记忆，从这里接上")).toBeNull();
   expect(
     screen
       .getByRole("navigation", { name: "首次设置进度" })
@@ -127,8 +133,8 @@ it("renders the final shell, double title, step one, branded rows and exact sour
   ).toContain("导入历史");
   expect(screen.getByRole("heading", { name: "本机 AI 应用" })).toBeTruthy();
   expect(
-    screen.getByText("确认前只检查应用信息，不读取对话，也不安装连接。"),
-  ).toBeTruthy();
+    screen.queryByText("确认前只检查应用信息，不读取对话，也不安装连接。"),
+  ).toBeNull();
   expect(screen.queryByRole("button", { name: "导入历史包" })).toBeNull();
   expect(screen.getByText("/fixture/workbuddy · 默认位置")).toBeTruthy();
   expect(
@@ -343,7 +349,7 @@ it("custom source cancel does not grant or select and accepted import retains re
   expect(
     (screen.getByLabelText("导入 codex 历史") as HTMLInputElement).checked,
   ).toBe(false);
-  fireEvent.click(screen.getByRole("button", { name: "开始导入" }));
+  fireEvent.click(await screen.findByRole("button", { name: "开始导入" }));
   await screen.findByText("已受理 workbuddy");
   expect(vi.mocked(imports.connectForOnboarding).mock.calls[0]?.[0]).toEqual([
     "workbuddy",
@@ -367,7 +373,7 @@ it("does not submit authorization when the first-step owner leaves during final
       done = resolve;
     }),
   );
-  fireEvent.click(screen.getByRole("button", { name: "开始导入" }));
+  fireEvent.click(await screen.findByRole("button", { name: "开始导入" }));
   view.unmount();
   await act(async () =>
     done({

memhub/apps/web/src/OnboardingFlow.tsx

@@ -1,9 +1,12 @@
 import type {
   ConnectSourcesResponse,
+  EvolveSchedule,
   ImportJob,
+  OnboardingModeIntent,
   OnboardingState,
   SourceResponse,
 } from "@one-memory/contracts";
+import { legacyMemoryModePlan } from "@one-memory/operations";
 import { Check, X } from "lucide-react";
 import {
   type CSSProperties,
@@ -18,10 +21,14 @@ import {
 import {
   apiErrorCode,
   completeOnboarding,
+  getEvolveSchedule,
   getMemoryMode,
+  getModelProfiles,
+  memoryModePlanUnsupported,
   patchOnboardingProgress,
   planMemoryMode,
   putOnboardingProgress,
+  setEvolveSchedule,
   setMemoryMode,
 } from "./api";
 import { AppMark } from "./app-mark";
@@ -40,18 +47,22 @@ import {
   hostCapabilities,
   hostWriteReason,
 } from "./host-state";
-import { MemoryModeChoiceList } from "./MemoryModeChoiceList";
+import { MemoryModeCards } from "./MemoryModeCards";
+import { BLOCKER_COPY } from "./memory-mode-ui";
 import { OnboardingModelController } from "./OnboardingModelController";
 import { useOnboardingTranslation } from "./onboarding-language";
 import { R6ColdStartFrame } from "./R6ColdStartFrame";
 import { R6Button } from "./R6Controls";
 import { traceUiAction } from "./ui-trace";
-import type { ImportSourcesController } from "./use-import-sources";
+import {
+  type ImportSourcesController,
+  isDefiniteAccessRefusal,
+} from "./use-import-sources";
 import { isDefiniteRefusal } from "./write-outcome";
 import "./cold-start.css";
 
 export type OnboardingDestination = "memory" | "sources" | "settings";
-type OnboardingMemoryMode = "lite" | "pro";
+type OnboardingMemoryMode = OnboardingModeIntent;
 
 // Cold start neither reads nor writes installation intent.
 export const PLUGIN_CONSENT_KEY = "one-memory.consent.plugins";
@@ -100,7 +111,7 @@ export function OnboardingFlow({
   imports: ImportSourcesController;
   onFinish(destination: OnboardingDestination): void;
 }) {
-  const { text, t } = useOnboardingTranslation();
+  const { text, t, locale } = useOnboardingTranslation();
   const [sources, setSources] = useState(imports.sources);
   const sourceGeneration = useRef({ value: imports.sources, epoch: 0 });
   if (sourceGeneration.current.value !== imports.sources) {
@@ -112,9 +123,8 @@ export function OnboardingFlow({
   const [locationCheck, setLocationCheck] = useState<LocationCheck>("checking");
   const [selected, setSelected] = useState<SourceResponse[]>([]);
   const [custom, setCustom] = useState<SourceResponse | null>(null);
-  const [busy, setBusy] = useState<
-    "checking" | "submitting" | "leaving" | null
-  >(null);
+  const [busy, setBusy] = useState<"checking" | "submitting" | null>(null);
+  const [completionBusy, setCompletionBusy] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [itemErrors, setItemErrors] = useState<Record<string, string>>({});
   const [exitDestination, setExitDestination] =
@@ -125,7 +135,9 @@ export function OnboardingFlow({
     null,
   );
   const resumedStep =
-    state.mode_intent === "pro" && state.setup_step === "model"
+    state.mode_intent &&
+    state.mode_intent !== "lite" &&
+    state.setup_step === "model"
       ? "model"
       : state.mode_intent
         ? "mode"
@@ -138,8 +150,19 @@ export function OnboardingFlow({
   );
   const [modeDestination, setModeDestination] =
     useState<OnboardingDestination>("sources");
-  const [modeSaving, setModeSaving] = useState(false);
+  const [modePhase, setModePhase] = useState<"idle" | "saving" | "completing">(
+    "idle",
+  );
+  const modeSaving = modePhase !== "idle";
   const [modeError, setModeError] = useState<string | null>(null);
+  const [knownMode, setKnownMode] = useState<OnboardingMemoryMode>("pro");
+  const [ultraSchedule, setUltraSchedule] = useState<EvolveSchedule>({
+    enabled: true,
+    time: "03:00",
+  });
+  const [scheduleLoaded, setScheduleLoaded] = useState(false);
+  const [scheduleReadFailed, setScheduleReadFailed] = useState(false);
+  const scheduleReadOperation = useRef(0);
   const [modeFocusToken, setModeFocusToken] = useState(
     resumedStep === "mode" ? 1 : 0,
   );
@@ -181,7 +204,10 @@ export function OnboardingFlow({
             )
             .join("、"),
         });
-  const flight = useRef(false);
+  const sourceFlight = useRef(false);
+  const modeOperation = useRef(0);
+  const proConfirmationOwner = useRef<string | null>(null);
+  const completionFlight = useRef(false);
   const connectionAttempt = useRef<string | null>(null);
   const connectionQueue = useRef(Promise.resolve());
   const connectionQueueDepth = useRef(0);
@@ -368,20 +394,24 @@ export function OnboardingFlow({
       selected.some((chosen) => chosen.source_id === item.source_id),
     );
   const locked =
-    busy !== null || exitDestination !== null || state.status === "importing";
+    busy !== null ||
+    completionBusy ||
+    exitDestination !== null ||
+    state.status === "importing";
 
   useEffect(() => {
     alive.current = true;
     const modeTicket = issueConfirmedModeTicket("onboarding");
     void getMemoryMode().then(
       (memoryMode) => {
-        if (alive.current)
+        if (alive.current) {
           commitConfirmedMemoryMode(memoryMode.mode, modeTicket);
+          setKnownMode(memoryMode.mode);
+        }
         if (
           alive.current &&
           !modeChoiceTouched.current &&
-          memoryMode.explicitly_configured &&
-          memoryMode.configured_mode !== "ultra"
+          memoryMode.explicitly_configured
         )
           setModeChoice(memoryMode.configured_mode);
       },
@@ -394,6 +424,32 @@ export function OnboardingFlow({
     };
   }, []);
 
+  const refreshUltraSchedule = useCallback(async () => {
+    const operation = ++scheduleReadOperation.current;
+    setScheduleLoaded(false);
+    setScheduleReadFailed(false);
+    try {
+      const schedule = await getEvolveSchedule();
+      if (!alive.current || scheduleReadOperation.current !== operation) return;
+      if (!schedule) return;
+      setUltraSchedule(schedule);
+      setScheduleLoaded(true);
+      setScheduleReadFailed(false);
+      setModeError((current) =>
+        current === "记忆模式状态暂时无法读取，请重试。" ? null : current,
+      );
+    } catch {
+      if (alive.current && scheduleReadOperation.current === operation) {
+        setScheduleLoaded(false);
+        setScheduleReadFailed(true);
+      }
+    }
+  }, []);
+
+  useEffect(() => {
+    void refreshUltraSchedule();
+  }, [refreshUltraSchedule]);
+
   useEffect(() => {
     setSources(imports.sources);
   }, [imports.sources]);
@@ -456,7 +512,7 @@ export function OnboardingFlow({
       locationCheck !== "ready" ||
       locked ||
       reviewingImport ||
-      flight.current
+      sourceFlight.current
     )
       return;
     if (!scopeMatches(selected, sources)) return;
@@ -483,17 +539,24 @@ export function OnboardingFlow({
     [onFinish],
   );
 
-  const enterModelStep = useCallback(() => {
-    intentRef.current = "pro";
-    setupStepRef.current = "model";
-    const token = ++modelGeneration.current;
-    setModelGenerationToken(token);
-    setVisitedModel(true);
-    setSetupStep("model");
-  }, []);
+  const enterModelStep = useCallback(
+    (mode: Exclude<OnboardingMemoryMode, "lite"> = "pro") => {
+      intentRef.current = mode;
+      setupStepRef.current = "model";
+      const token = ++modelGeneration.current;
+      setModelGenerationToken(token);
+      setVisitedModel(true);
+      setSetupStep("model");
+    },
+    [],
+  );
 
   const leaveModelStep = useCallback(
-    (nextIntent: OnboardingMemoryMode, nextStep: "review" | "mode") => {
+    (
+      nextIntent: OnboardingMemoryMode,
+      nextStep: "review" | "mode",
+      resetModePhase = true,
+    ) => {
       // This fence is synchronous: hidden model work must observe invalidation
       // before React renders the replacement step.
       modelGeneration.current += 1;
@@ -502,7 +565,10 @@ export function OnboardingFlow({
       setModeChoice(nextIntent);
       setSetupStep(nextStep);
       if (nextStep === "mode") setModeFocusToken((value) => value + 1);
-      setModeSaving(false);
+      if (resetModePhase) {
+        modeOperation.current += 1;
+        setModePhase("idle");
+      }
     },
     [],
   );
@@ -611,12 +677,15 @@ export function OnboardingFlow({
 
   const leave = useCallback(
     async (destination: OnboardingDestination) => {
-      if (flight.current || finished.current) return;
-      flight.current = true;
-      setBusy("leaving");
-      await persistFinish(destination);
-      flight.current = false;
-      if (alive.current) setBusy(null);
+      if (completionFlight.current || finished.current) return;
+      completionFlight.current = true;
+      setCompletionBusy(true);
+      try {
+        await persistFinish(destination);
+      } finally {
+        completionFlight.current = false;
+        if (alive.current) setCompletionBusy(false);
+      }
     },
     [persistFinish],
   );
@@ -624,7 +693,8 @@ export function OnboardingFlow({
   const requestModeChoice = useCallback(
     (destination: OnboardingDestination) => {
       if (finished.current) return;
-      if (setupStepRef.current === "model") leaveModelStep("pro", "mode");
+      if (setupStepRef.current === "model")
+        leaveModelStep(intentRef.current === "ultra" ? "ultra" : "pro", "mode");
       else {
         intentRef.current = modeChoice;
         setupStepRef.current = "mode";
@@ -639,30 +709,97 @@ export function OnboardingFlow({
     [leaveModelStep, modeChoice],
   );
 
+  const loadModePlan = useCallback(
+    async (target: OnboardingMemoryMode) => {
+      try {
+        return await planMemoryMode(target);
+      } catch (reason) {
+        if (!memoryModePlanUnsupported(reason)) throw reason;
+        const profiles = await getModelProfiles();
+        return legacyMemoryModePlan(knownMode, target, {
+          hasActiveModel: profiles.some((profile) => profile.is_active),
+        });
+      }
+    },
+    [knownMode],
+  );
+
   const saveModeChoice = useCallback(async () => {
-    if (
-      !modeChoice ||
-      modeSaving ||
-      finished.current ||
-      (modeChoice === "lite" && flight.current)
-    )
-      return;
-    setModeSaving(true);
+    if (!modeChoice || modeSaving || finished.current || completionBusy) return;
+    const operation = ++modeOperation.current;
+    const ownsModeOperation = () =>
+      alive.current && !finished.current && modeOperation.current === operation;
+    setModePhase("saving");
     setModeError(null);
     const modeTicket = issueConfirmedModeTicket("onboarding");
     try {
-      if (modeChoice === "pro") {
-        intentRef.current = "pro";
+      if (modeChoice !== "lite") {
+        const target = modeChoice;
+        const [plan, profiles] = await Promise.all([
+          loadModePlan(target),
+          getModelProfiles(),
+        ]);
+        if (!ownsModeOperation()) return;
+        const hasActiveModel = profiles.some((profile) => profile.is_active);
+        if (target === "ultra" && !scheduleLoaded) {
+          setModeError(
+            scheduleReadFailed
+              ? "记忆模式状态暂时无法读取，请重试。"
+              : "正在读取记忆模式…",
+          );
+          return;
+        }
+        const blocking = plan.blockers.filter(
+          (blocker) => blocker !== "active_model_required",
+        );
+        if (blocking.length > 0) {
+          setModeError(
+            blocking.map((blocker) => BLOCKER_COPY[blocker]).join(" "),
+          );
+          return;
+        }
+        intentRef.current = target;
         setupStepRef.current = "mode";
         const selectionStillCurrent = () =>
-          alive.current &&
-          !finished.current &&
-          intentRef.current === "pro" &&
+          ownsModeOperation() &&
+          intentRef.current === target &&
           setupStepRef.current === "mode";
+        if (
+          hasActiveModel &&
+          !plan.blockers.includes("active_model_required")
+        ) {
+          const changed = await queueModeWrite(target, selectionStillCurrent);
+          if (!selectionStillCurrent()) return;
+          commitConfirmedMemoryMode(changed.mode, modeTicket);
+          setKnownMode(changed.mode);
+          if (target === "ultra") {
+            try {
+              await setEvolveSchedule(ultraSchedule);
+            } catch {
+              if (selectionStillCurrent())
+                setModeError("自动整合设置未能保存，请重试。");
+              return;
+            }
+            if (!selectionStillCurrent()) return;
+          }
+          await queueProgressWrite(
+            () =>
+              putOnboardingProgress({
+                mode_intent: target,
+                setup_step: "mode",
+                model_profile_id: null,
+              }),
+            selectionStillCurrent,
+          );
+          if (!selectionStillCurrent()) return;
+          setModePhase("completing");
+          await leave(modeDestination);
+          return;
+        }
         const savedProgress = await queueProgressWrite(
           () =>
             putOnboardingProgress({
-              mode_intent: "pro",
+              mode_intent: target,
               setup_step: "model",
               model_profile_id: modelProfileId.current,
             }),
@@ -670,15 +807,26 @@ export function OnboardingFlow({
         );
         if (!selectionStillCurrent()) return;
         modelProfileId.current = savedProgress.model_profile_id;
-        enterModelStep();
+        enterModelStep(target);
         return;
       }
-      leaveModelStep("lite", "mode");
+      leaveModelStep("lite", "mode", false);
       const liteStillCurrent = () =>
-        alive.current &&
-        !finished.current &&
+        ownsModeOperation() &&
         intentRef.current === "lite" &&
         setupStepRef.current === "mode";
+      const plan = await loadModePlan("lite");
+      if (!liteStillCurrent()) return;
+      if (plan.blockers.length > 0) {
+        setModeError(
+          plan.blockers.map((blocker) => BLOCKER_COPY[blocker]).join(" "),
+        );
+        return;
+      }
+      const changed = await queueModeWrite("lite", liteStillCurrent);
+      if (!liteStillCurrent()) return;
+      commitConfirmedMemoryMode(changed.mode, modeTicket);
+      setKnownMode(changed.mode);
       await queueProgressWrite(
         () =>
           putOnboardingProgress({
@@ -688,19 +836,17 @@ export function OnboardingFlow({
           }),
         liteStillCurrent,
       );
-      if (!alive.current) return;
-      const changed = await queueModeWrite("lite");
-      if (!alive.current) return;
-      commitConfirmedMemoryMode(changed.mode, modeTicket);
+      if (!liteStillCurrent()) return;
+      setModePhase("completing");
       await leave(modeDestination);
     } catch (reason) {
       if (isCompletedProgressConflict(reason)) {
         finishOnce(modeDestination);
-      } else if (alive.current) {
+      } else if (ownsModeOperation() && !isGenerationInvalid(reason)) {
         setModeError("模式未能保存。你的选择已保留，请重试。");
       }
     } finally {
-      if (alive.current) setModeSaving(false);
+      if (ownsModeOperation()) setModePhase("idle");
     }
   }, [
     enterModelStep,
@@ -709,9 +855,14 @@ export function OnboardingFlow({
     modeChoice,
     modeDestination,
     modeSaving,
+    completionBusy,
     finishOnce,
+    loadModePlan,
     queueModeWrite,
     queueProgressWrite,
+    scheduleLoaded,
+    scheduleReadFailed,
+    ultraSchedule,
   ]);
 
   const persistModelProfile = useCallback(
@@ -729,58 +880,101 @@ export function OnboardingFlow({
     [queueProgressWrite],
   );
 
-  const confirmProMode = useCallback(
+  const confirmModelMode = useCallback(
     async (token: number, ownerProfileId: string) => {
+      const target = intentRef.current;
+      if (target !== "pro" && target !== "ultra") return;
+      if (target === "ultra" && !scheduleLoaded) {
+        leaveModelStep("ultra", "mode");
+        setModeError(
+          scheduleReadFailed
+            ? "记忆模式状态暂时无法读取，请重试。"
+            : "正在读取记忆模式…",
+        );
+        return;
+      }
+      const confirmationOwner = `${token}:${ownerProfileId}:${target}`;
       const ownsModelStep = () =>
         alive.current &&
         !finished.current &&
         modelGeneration.current === token &&
-        intentRef.current === "pro" &&
+        intentRef.current === target &&
         setupStepRef.current === "model" &&
         modelProfileId.current === ownerProfileId;
-      if (!ownsModelStep()) return;
-      setModeSaving(true);
+      if (
+        !ownsModelStep() ||
+        proConfirmationOwner.current === confirmationOwner ||
+        completionBusy
+      )
+        return;
+      proConfirmationOwner.current = confirmationOwner;
+      const operation = ++modeOperation.current;
+      const ownsConfirmation = () =>
+        ownsModelStep() && modeOperation.current === operation;
+      setModePhase("saving");
       setModeError(null);
       const modeTicket = issueConfirmedModeTicket("onboarding");
       try {
-        const plan = await planMemoryMode("pro");
-        if (!ownsModelStep()) return;
+        const plan = await loadModePlan(target);
+        if (!ownsConfirmation()) return;
         if (plan.blockers.length > 0) throw new Error(plan.blockers.join(","));
-        const changed = await queueModeWrite("pro", ownsModelStep);
-        if (!ownsModelStep()) return;
+        const changed = await queueModeWrite(target, ownsConfirmation);
+        if (!ownsConfirmation()) return;
         commitConfirmedMemoryMode(changed.mode, modeTicket);
+        setKnownMode(changed.mode);
+        if (target === "ultra") {
+          try {
+            await setEvolveSchedule(ultraSchedule);
+          } catch {
+            if (ownsConfirmation()) {
+              leaveModelStep("ultra", "mode");
+              setModeError("自动整合设置未能保存，请重试。");
+            }
+            return;
+          }
+          if (!ownsConfirmation()) return;
+        }
         await queueProgressWrite(
           () =>
             putOnboardingProgress({
-              mode_intent: "pro",
+              mode_intent: target,
               setup_step: "model",
               model_profile_id: ownerProfileId,
             }),
-          ownsModelStep,
+          ownsConfirmation,
         );
-        if (!ownsModelStep()) return;
-        await persistFinish(modeDestination);
+        if (!ownsConfirmation()) return;
+        setModePhase("completing");
+        await leave(modeDestination);
       } catch (reason) {
         if (isCompletedProgressConflict(reason)) {
           finishOnce(modeDestination);
-        } else if (alive.current && !isGenerationInvalid(reason))
-          setModeError("Pro 模式未能确认保存。模型配置已保留，请重试。");
+        } else if (ownsConfirmation() && !isGenerationInvalid(reason))
+          setModeError("模式切换未能确认，仍显示上次确认的模式。");
       } finally {
-        if (alive.current) setModeSaving(false);
+        if (proConfirmationOwner.current === confirmationOwner)
+          proConfirmationOwner.current = null;
+        if (ownsConfirmation()) setModePhase("idle");
       }
     },
     [
+      completionBusy,
       finishOnce,
+      leave,
+      leaveModelStep,
+      loadModePlan,
       modeDestination,
-      persistFinish,
       queueModeWrite,
       queueProgressWrite,
+      scheduleLoaded,
+      scheduleReadFailed,
+      ultraSchedule,
     ],
   );
 
   async function checkLocations() {
-    if (flight.current || locked) return;
-    flight.current = true;
+    if (sourceFlight.current || locked) return;
+    sourceFlight.current = true;
     scopeVersion.current += 1;
     setBusy("checking");
     setLocationCheck("checking");
@@ -805,7 +999,7 @@ export function OnboardingFlow({
       setLocationCheck("failed");
       setError("位置检测未完成，尚未读取历史。可以重新检测，或先进入工作台。");
     } finally {
-      flight.current = false;
+      sourceFlight.current = false;
       if (alive.current) setBusy(null);
     }
   }
@@ -813,7 +1007,7 @@ export function OnboardingFlow({
 
   function toggleSource(source: SourceResponse, checked: boolean) {
     if (
-      flight.current ||
+      sourceFlight.current ||
       locked ||
       locationCheck !== "ready" ||
       !isAppSource(source) ||
@@ -836,7 +1030,7 @@ export function OnboardingFlow({
   }
 
   function selectAllSources() {
-    if (flight.current || locked || locationCheck !== "ready") return;
+    if (sourceFlight.current || locked || locationCheck !== "ready") return;
     scopeVersion.current += 1;
     setError(null);
     setItemErrors({});
@@ -849,7 +1043,7 @@ export function OnboardingFlow({
 
   async function startImport() {
     if (
-      flight.current ||
+      sourceFlight.current ||
       locked ||
       locationCheck !== "ready" ||
       !selected.length
@@ -863,7 +1057,7 @@ export function OnboardingFlow({
   }
 
   async function submitImport(approved: SourceResponse[]) {
-    flight.current = true;
+    sourceFlight.current = true;
     if (window.oneMemory) setStartingImport(approved);
     const version = scopeVersion.current;
     const retryFailed = Object.keys(itemErrors).length > 0;
@@ -908,21 +1102,26 @@ export function OnboardingFlow({
       setAccepted(result);
       setStartingImport(null);
       setError(null);
-    } catch {
+    } catch (reason) {
       if (alive.current) {
-        setStartingImport(null);
+        const refused = isDefiniteAccessRefusal(reason);
+        if (refused) setStartingImport(null);
         setError(
-          "开始导入的结果尚未确认，选择已保留。可以重试，或进入应用页核对。",
+          refused
+            ? "本次没有来源获准导入。请核对下方原因后重试，或到应用页查看状态。"
+            : "开始导入的结果尚未确认，选择已保留。可以重试，或进入应用页核对。",
         );
       }
     } finally {
       connectSent.current = false;
-      flight.current = false;
+      sourceFlight.current = false;
       if (alive.current) setBusy(null);
     }
   }
 
   const count = selected.length;
+  const continueWithoutImport =
+    busy === null && locationCheck !== "checking" && count === 0;
   // D51 item 3: only a *confirmed* snapshot may show a number. A failed
   // detection must read 未完成 even when sources are listed — otherwise the
   // number branch answered first and the summary claimed a count while the
@@ -987,10 +1186,10 @@ export function OnboardingFlow({
             jobs={reviewJobs}
             failedSources={accepted?.failed_sources}
             sourceSnapshot={imports.sourceSnapshot}
-            busy={busy === "leaving"}
+            busy={completionBusy}
             error={error && text(error)}
             onContinue={(destination) => {
-              if (busy === "leaving") return;
+              if (completionBusy) return;
               if (completionFailed) {
                 void leave(destination);
                 return;
@@ -1025,96 +1224,85 @@ export function OnboardingFlow({
           <R6ColdStartFrame
             step={3}
             title={text("选择记忆模式")}
-            eyebrow={text("最后一步 · 决定如何处理对话")}
             focusToken={modeFocusToken}
             footer={
-              <>
-                <R6Button
-                  variant="quiet"
-                  disabled={modeSaving || busy === "leaving"}
-                  onClick={() => {
-                    setModeError(null);
-                    intentRef.current = modeChoice;
-                    setupStepRef.current = "review";
-                    setSetupStep("review");
-                    void queueProgressWrite(() =>
-                      patchOnboardingProgress({
-                        mode_intent: modeChoice,
-                        setup_step: "review",
-                      }),
-                    ).catch((reason) => {
-                      if (!isCompletedProgressConflict(reason) && alive.current)
-                        setModeError(
-                          "恢复进度未能保存。你的选择已保留，请重试。",
-                        );
-                    });
-                  }}
-                >
-                  {text("返回导入")}
-                </R6Button>
-                <R6Button
-                  className="onboarding-r6-submit"
-                  variant="primary"
-                  pending={modeSaving}
-                  disabled={
-                    !modeChoice ||
-                    busy === "leaving" ||
-                    (modeChoice === "lite" && flight.current)
-                  }
-                  onClick={() => void saveModeChoice()}
-                >
-                  {text(
-                    modeSaving
-                      ? "正在保存…"
+              <R6Button
+                className="onboarding-r6-submit"
+                variant="primary"
+                pending={modeSaving}
+                disabled={
+                  !modeChoice ||
+                  completionBusy ||
+                  (modeChoice === "ultra" && !scheduleLoaded)
+                }
+                onClick={() => void saveModeChoice()}
+              >
+                {text(
+                  modePhase === "saving"
+                    ? "正在保存模式…"
+                    : modePhase === "completing"
+                      ? "正在完成首次设置…"
                       : modeChoice === "lite"
                         ? "使用 Lite 进入"
                         : modeChoice === "pro"
                           ? "继续配置模型"
                           : "继续",
-                  )}
-                </R6Button>
-              </>
+                )}
+              </R6Button>
             }
           >
             <section
               className="onboarding-r6-mode"
-              aria-labelledby="onboarding-memory-mode-title"
+              aria-label={text("记忆模式")}
             >
               <div className="onboarding-r6-mode-intro">
-                <p id="onboarding-memory-mode-title">
-                  {text("之后可在设置中更改。")}
-                </p>
+                <h2>
+                  {locale === "zh-Hans"
+                    ? "Choose how MemHub remembers"
+                    : text("你希望 MemHub 如何形成记忆？")}
+                </h2>
+                <p>{text("需要明确选择一种方式；之后仍可在设置中更改。")}</p>
               </div>
-              <MemoryModeChoiceList
+              <MemoryModeCards
                 aria-label={text("记忆模式")}
-                modes={[
-                  {
-                    mode: "lite",
-                    title: "Lite",
-                    description: text(
-                      "无需模型，只保存并检索原始对话，不生成提炼记忆。",
-                    ),
-                  },
-                  {
-                    mode: "pro",
-                    title: "Pro",
-                    description: text(
-                      "使用模型理解对话，提取并整理可持续生长的记忆。",
-                    ),
-                  },
-                ]}
-                selected={modeChoice}
-                disabled={modeSaving || busy === "leaving"}
-                recommended={{ mode: "pro", badge: text("推荐") }}
+                value={modeChoice}
+                layout="rows"
+                disabled={modeSaving || completionBusy}
                 onChange={(mode) => {
                   modeChoiceTouched.current = true;
-                  setModeChoice(mode as OnboardingMemoryMode);
+                  intentRef.current = mode;
+                  setModeChoice(mode);
                   setModeError(null);
                 }}
+                ultraDetail={
+                  scheduleLoaded ? (
+                    <div className="onboarding-r6-ultra-default">
+                      <strong>{text("每天自动整合")}</strong>
+                      <small>
+                        {text(
+                          ultraSchedule.enabled
+                            ? "每天 {time} 左右自动整合，使用这台设备的本地时间；休眠错过后会补跑。"
+                            : "已关闭。重新开启后仍按 {time} 运行；已生成的结果会保留。",
+                        ).replace("{time}", ultraSchedule.time)}
+                      </small>
+                    </div>
+                  ) : scheduleReadFailed ? (
+                    <div className="onboarding-r6-schedule-recovery">
+                      <p role="alert">
+                        {text("记忆模式状态暂时无法读取，请重试。")}
+                      </p>
+                      <R6Button
+                        className="onboarding-r6-schedule-retry"
+                        onClick={() => void refreshUltraSchedule()}
+                      >
+                        {text("重试")}
+                      </R6Button>
+                    </div>
+                  ) : (
+                    <p>{text("正在读取自动整合设置…")}</p>
+                  )
+                }
               />
-              <p className="onboarding-r6-mode-ultra-note">
-                {text("Ultra 可在完成首次设置后到设置页开启。")}
-              </p>
               {(modeError || error) && (
                 <p className="onboarding-r6-mode-error" role="alert">
                   {text(modeError ?? error ?? "")}
@@ -1129,7 +1317,8 @@ export function OnboardingFlow({
               generationToken={modelGenerationToken}
               isGenerationCurrent={(token) =>
                 modelGeneration.current === token &&
-                intentRef.current === "pro" &&
+                intentRef.current !== "lite" &&
+                intentRef.current !== null &&
                 setupStepRef.current === "model"
               }
               initialProfileId={modelProfileId.current}
@@ -1142,7 +1331,7 @@ export function OnboardingFlow({
                 void persistModelProfile(profileId)
               }
               onModelActiveConfirmed={(token, ownerProfileId) =>
-                void confirmProMode(token, ownerProfileId)
+                void confirmModelMode(token, ownerProfileId)
               }
               sourceNames={sourceIds.map(
                 (id) =>
@@ -1157,10 +1346,11 @@ export function OnboardingFlow({
                 )}
               onBack={() => {
                 setModeError(null);
-                leaveModelStep("pro", "mode");
+                const target = intentRef.current === "ultra" ? "ultra" : "pro";
+                leaveModelStep(target, "mode");
                 void queueProgressWrite(() =>
                   putOnboardingProgress({
-                    mode_intent: "pro",
+                    mode_intent: target,
                     setup_step: "mode",
                     model_profile_id: modelProfileId.current,
                   }),
@@ -1188,7 +1378,7 @@ export function OnboardingFlow({
           <>
             <R6Button
               variant="quiet"
-              disabled={busy !== null}
+              disabled={busy !== null || completionBusy}
               onClick={() => finishOnce(exitDestination)}
             >
               {text(
@@ -1197,7 +1387,7 @@ export function OnboardingFlow({
             </R6Button>
             <R6Button
               variant="primary"
-              disabled={busy !== null}
+              disabled={busy !== null || completionBusy}
               onClick={() => void leave(exitDestination)}
             >
               {text("重试保存并进入")}
@@ -1215,16 +1405,8 @@ export function OnboardingFlow({
     <R6ColdStartFrame
       step={1}
       title={text("把熟悉的背景，带到这里")}
-      eyebrow={text("你的记忆，从这里接上")}
       footer={
         <>
-          <R6Button
-            variant="quiet"
-            disabled={locked}
-            onClick={() => requestModeChoice("sources")}
-          >
-            {text("稍后添加，先进入")}
-          </R6Button>
           {error && (
             <p className="onboarding-r6-error" role="alert">
               {error && text(error)}
@@ -1233,10 +1415,20 @@ export function OnboardingFlow({
           <R6Button
             className="onboarding-r6-submit"
             variant="primary"
-            disabled={locked || count === 0}
-            onClick={() => void startImport()}
+            disabled={locked}
+            onClick={() =>
+              continueWithoutImport
+                ? requestModeChoice("sources")
+                : void startImport()
+            }
           >
-            {text(busy === "submitting" ? "正在开始导入…" : "开始导入")}
+            {text(
+              continueWithoutImport
+                ? "选择记忆模式"
+                : busy === "submitting"
+                  ? "正在开始导入…"
+                  : "开始导入",
+            )}
           </R6Button>
         </>
       }
@@ -1246,12 +1438,6 @@ export function OnboardingFlow({
           className="onboarding-r6-apps"
           aria-labelledby="cold-start-phase"
         >
-          <div className="onboarding-r6-intro">
-            <p>
-              {text("不用从头介绍自己。从常用的 App 开始，把已有背景带过来。")}
-            </p>
-            <p>{text("确认前只检查应用信息，不读取对话，也不安装连接。")}</p>
-          </div>
           <div className="onboarding-r6-list-heading">
             <h2 id="cold-start-phase" ref={heading} tabIndex={-1}>
               {text("本机 AI 应用")}

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

@@ -23,7 +23,17 @@ const { embedding, getModelProfiles, models, step } = vi.hoisted(() => ({
         max_concurrency: 4,
         context_window: null,
         has_api_key: true,
+        credential_state: "available" as
+          | "available"
+          | "missing"
+          | "unavailable",
         is_active: true,
+        capabilities: {
+          endpoint_reachable: true,
+          model_available: true,
+          embedding_available: true,
+          structured_output: false,
+        },
       },
     ],
     pendingProbe: null as null | {
@@ -57,7 +67,7 @@ const { embedding, getModelProfiles, models, step } = vi.hoisted(() => ({
     supported: false as boolean | null,
     planActivation: vi.fn(),
     startPlannedSwitch: vi.fn(),
-    shouldUseLegacyActivation: () => true,
+    shouldUseLegacyActivation: (() => true) as () => boolean,
     clearPlan: vi.fn(),
     clearError: vi.fn(),
   },
@@ -123,6 +133,7 @@ beforeEach(() => {
   models.creationMissing = null;
   embedding.current = null;
   embedding.supported = false;
+  embedding.shouldUseLegacyActivation = () => true;
   step.current = null;
 });
 
@@ -164,6 +175,32 @@ it("resumes and confirms the active profile explicitly owned by onboarding", asy
   expect(enabled).toHaveBeenCalledWith(1, "active-profile");
 });
 
+it("does not complete with an active profile whose credential is unavailable", async () => {
+  models.profiles = [
+    {
+      ...activeProfile,
+      credential_state: "unavailable",
+    },
+  ];
+  const enabled = vi.fn();
+  render(
+    <OnboardingModelController
+      sourceNames={[]}
+      initialProfileId="active-profile"
+      onBack={vi.fn()}
+      onModelActiveConfirmed={enabled}
+    />,
+  );
+
+  await waitFor(() => expect(step.current).not.toBeNull());
+  expect(enabled).not.toHaveBeenCalled();
+  await userEvent.click(
+    screen.getByRole("button", { name: "继续使用当前模型" }),
+  );
+  expect(enabled).not.toHaveBeenCalled();
+  expect(screen.getByText(/模型凭据或连接状态已变化/)).toBeTruthy();
+});
+
 it("hydrates a persisted inactive profile without creating a duplicate", async () => {
   models.profiles = [{ ...activeProfile, is_active: false }];
   const active = vi.fn();
@@ -206,7 +243,7 @@ it("recovers a pending creation and persists its profile id", async () => {
 });
 
 it("reconciles a pending probe instead of saving or creating again", async () => {
-  const inactive = { ...activeProfile, is_active: false };
+  const inactive = { ...activeProfile, revision: 4, is_active: false };
   models.profiles = [inactive];
   models.pendingProbe = {
     operationId: "probe-operation",
@@ -215,7 +252,8 @@ it("reconciles a pending probe instead of saving or creating again", async () =>
   };
   models.probeProfile.mockResolvedValueOnce({
     profile_id: "active-profile",
-    profile_revision: 3,
+    input_profile_revision: 3,
+    profile_revision: 4,
     capabilities: {
       endpoint_reachable: true,
       model_available: true,
@@ -238,10 +276,76 @@ it("reconciles a pending probe instead of saving or creating again", async () =>
   await waitFor(() =>
     expect(models.probeProfile).toHaveBeenCalledWith("active-profile"),
   );
+  await waitFor(() =>
+    expect(screen.getByText("模型连接测试通过，可以启用。")).toBeTruthy(),
+  );
+  expect(currentStep().canSaveAndEnable).toBe(true);
   expect(models.update).not.toHaveBeenCalled();
   expect(models.create).not.toHaveBeenCalled();
 });
 
+it("passes the first test when Core advances the tested profile revision", async () => {
+  const inactive = { ...activeProfile, revision: 1, is_active: false };
+  models.profiles = [inactive];
+  models.update.mockResolvedValueOnce(inactive);
+  models.probeProfile.mockResolvedValueOnce({
+    profile_id: inactive.profile_id,
+    input_profile_revision: 1,
+    profile_revision: 2,
+    capabilities: {
+      endpoint_reachable: true,
+      model_available: true,
+      embedding_available: true,
+    },
+    stages: [{ ok: false }],
+  });
+  models.activate.mockResolvedValueOnce({
+    ...inactive,
+    revision: 2,
+    is_active: true,
+    capabilities: {
+      endpoint_reachable: true,
+      model_available: true,
+      embedding_available: true,
+    },
+  });
+  embedding.supported = true;
+  embedding.current = { writes_paused: false };
+  embedding.shouldUseLegacyActivation = () => false;
+  embedding.planActivation.mockResolvedValueOnce({ needed: false });
+  const confirmed = vi.fn();
+  render(
+    <OnboardingModelController
+      sourceNames={[]}
+      initialProfileId={inactive.profile_id}
+      onBack={vi.fn()}
+      onModelActiveConfirmed={confirmed}
+    />,
+  );
+  await waitFor(() =>
+    expect(
+      (currentStep().profile as { profile_id: string } | null)?.profile_id,
+    ).toBe(inactive.profile_id),
+  );
+
+  await act(async () => {
+    await (currentStep().onTest as () => Promise<void>)();
+  });
+
+  await waitFor(() =>
+    expect(screen.getByText("模型连接测试通过，可以启用。")).toBeTruthy(),
+  );
+  expect(currentStep().canSaveAndEnable).toBe(true);
+  expect(currentStep().profile).toMatchObject({ revision: 2 });
+  expect(getModelProfiles).not.toHaveBeenCalled();
+  await act(async () => {
+    await (currentStep().onSaveAndEnable as () => Promise<void>)();
+  });
+  expect(embedding.planActivation).toHaveBeenCalledWith(inactive.profile_id, 2);
+  expect(models.activate).toHaveBeenCalledWith(inactive.profile_id);
+  expect(confirmed).toHaveBeenCalledWith(1, inactive.profile_id);
+});
+
 it("keeps an active resumed profile on the model step while writes are paused", async () => {
   embedding.supported = true;
   embedding.current = { writes_paused: true };

memhub/apps/web/src/OnboardingModelController.tsx

@@ -1,16 +1,15 @@
 import type {
-  ModelProbeResult,
   ModelProfile,
   ModelProfileInput,
   ModelProfilePatch,
 } from "@one-memory/contracts";
-import { useEffect, useRef, useState } from "react";
-import { getModelProfiles } from "./api";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { EmbeddingSwitchConfirmDialog } from "./EmbeddingSwitchExperience";
 import {
   presetForGeneration,
   validateGenerationModel,
 } from "./GenerationModelPrimitives";
+import { modelProfileReady, profileFromProbe } from "./model-profile-readiness";
 import {
   type OnboardingModelDraft,
   OnboardingModelStep,
@@ -41,23 +40,6 @@ const initial: OnboardingModelDraft = {
   context_window: "",
 };
 
-export function probeMatchesProfile(
-  original: ModelProfile,
-  current: ModelProfile | undefined,
-  probe: ModelProbeResult | undefined | null,
-): current is ModelProfile {
-  return Boolean(
-    current &&
-      probe &&
-      probe.profile_id === original.profile_id &&
-      probe.profile_revision === current.revision &&
-      probe.capabilities.endpoint_reachable &&
-      probe.capabilities.model_available &&
-      probe.capabilities.embedding_available &&
-      probe.stages.every((stage) => stage.ok),
-  );
-}
-
 export function OnboardingModelController({
   sourceNames,
   importedConversationCount = 0,
@@ -112,6 +94,17 @@ export function OnboardingModelController({
     >(),
   );
   const autoConfirmed = useRef<string | null>(null);
+  const confirmReadyProfile = useCallback(
+    (profile: ModelProfile, owner = generationToken) => {
+      if (!isGenerationCurrent(owner) || !modelProfileReady(profile)) {
+        setError("模型凭据或连接状态已变化，请重新测试后再完成首次设置。");
+        return false;
+      }
+      onModelActiveConfirmed?.(owner, profile.profile_id);
+      return true;
+    },
+    [generationToken, isGenerationCurrent, onModelActiveConfirmed],
+  );
 
   useEffect(() => {
     const profile = initialProfileId
@@ -152,21 +145,19 @@ export function OnboardingModelController({
   useEffect(() => {
     if (
       !saved?.is_active ||
-      !isGenerationCurrent(generationToken) ||
       (embeddingSwitch.supported !== false && !embeddingSwitch.current) ||
       embeddingSwitch.current?.writes_paused
     )
       return;
     const key = `${generationToken}:${saved.profile_id}`;
     if (autoConfirmed.current === key) return;
-    autoConfirmed.current = key;
-    onModelActiveConfirmed?.(generationToken, saved.profile_id);
+    if (confirmReadyProfile(saved, generationToken))
+      autoConfirmed.current = key;
   }, [
     embeddingSwitch.current,
     embeddingSwitch.supported,
+    confirmReadyProfile,
     generationToken,
-    isGenerationCurrent,
-    onModelActiveConfirmed,
     saved,
   ]);
 
@@ -182,8 +173,7 @@ export function OnboardingModelController({
       flight.current = false;
       setSwitchPendingJobId(null);
       setPhase("idle");
-      if (saved && isGenerationCurrent(generationToken))
-        onModelActiveConfirmed?.(generationToken, saved.profile_id);
+      if (saved) confirmReadyProfile(saved, generationToken);
     } else if (finished.state === "rolled_back") {
       flight.current = false;
       setSwitchPendingJobId(null);
@@ -192,9 +182,8 @@ export function OnboardingModelController({
     }
   }, [
     embeddingSwitch.current?.last_finished,
+    confirmReadyProfile,
     generationToken,
-    isGenerationCurrent,
-    onModelActiveConfirmed,
     saved,
     switchPendingJobId,
   ]);
@@ -338,11 +327,10 @@ export function OnboardingModelController({
       setPhase("testing");
       const result = await models.probeProfile(profile.profile_id);
       if (!isGenerationCurrent(owner)) return;
-      const current = (await getModelProfiles()).find(
-        (item) => item.profile_id === profile.profile_id,
+      const current = profileFromProbe(profile, result);
+      const passed = Boolean(
+        current && modelProfileReady(current, result ?? null),
       );
-      if (!isGenerationCurrent(owner)) return;
-      const passed = probeMatchesProfile(profile, current, result);
       if (current) setSaved(current);
       setProbe({
         state: passed ? "passed" : "failed",
@@ -378,11 +366,10 @@ export function OnboardingModelController({
     try {
       const result = await models.probeProfile(saved.profile_id);
       if (!isGenerationCurrent(owner)) return;
-      const current = (await getModelProfiles()).find(
-        (item) => item.profile_id === saved.profile_id,
+      const current = profileFromProbe(saved, result);
+      const passed = Boolean(
+        current && modelProfileReady(current, result ?? null),
       );
-      if (!isGenerationCurrent(owner)) return;
-      const passed = probeMatchesProfile(saved, current, result);
       if (current) setSaved(current);
       setProbe({
         state: passed ? "passed" : "failed",
@@ -408,8 +395,7 @@ export function OnboardingModelController({
         setError("模型写入暂时关闭。请等待索引维护完成后重试。");
         return;
       }
-      if (isGenerationCurrent(generationToken))
-        onModelActiveConfirmed?.(generationToken, saved.profile_id);
+      confirmReadyProfile(saved, generationToken);
       return;
     }
     const owner = generationToken;
@@ -433,9 +419,15 @@ export function OnboardingModelController({
       }
       const active = await models.activate(saved.profile_id);
       if (!isGenerationCurrent(owner)) return;
-      if (!active?.is_active) throw new Error("model_activation_unconfirmed");
+      if (
+        !active?.is_active ||
+        active.profile_id !== saved.profile_id ||
+        active.revision !== saved.revision ||
+        !modelProfileReady(active)
+      )
+        throw new Error("model_activation_unconfirmed");
       trace.done("succeeded");
-      onModelActiveConfirmed?.(owner, active.profile_id);
+      confirmReadyProfile(active, owner);
     } catch {
       trace.done("unknown", { reason: "model_enable_unconfirmed" });
       setError("模型未能确认启用，请在设置中核对。");

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

@@ -76,7 +76,9 @@ describe("OnboardingModelStep", () => {
     localStorage.setItem(LANGUAGE_STORAGE_KEY, locale);
     const title = guiMessages[locale]["配置记忆整理模型"];
     const back = guiMessages[locale]["返回选择模式"];
-    if (!title || !back) throw new Error(`missing ${locale} model copy`);
+    const summary = guiMessages[locale]["记忆整理"];
+    if (!title || !back || !summary)
+      throw new Error(`missing ${locale} model copy`);
     render(
       <LanguageProvider>
         <OnboardingModelStep {...props()} />
@@ -93,10 +95,11 @@ describe("OnboardingModelStep", () => {
       }),
     ).toBeTruthy();
     expect(screen.getByLabelText(/API Key/)).toBeTruthy();
+    expect(screen.getByRole("complementary", { name: summary })).toBeTruthy();
     expect(screen.getAllByRole("button").length).toBeGreaterThanOrEqual(4);
   });
 
-  it("keeps step 3 on memory mode in a generation-only column", () => {
+  it("keeps current behavior in the restored open-source composition", () => {
     render(<OnboardingModelStep {...props()} />);
     expect(
       screen.getByRole("heading", { name: "配置记忆整理模型" }),
@@ -110,12 +113,9 @@ describe("OnboardingModelStep", () => {
     expect(screen.getByText("DeepSeek · deepseek-flash")).toBeTruthy();
     expect(screen.queryByText("本次沉淀")).toBeNull();
     expect(screen.queryByLabelText(/向量|Embedding/)).toBeNull();
-    expect(
-      document.querySelector(
-        ".onboarding-model-layout--single-column-600" +
-          '[data-responsive="single-column-600"]',
-      ),
-    ).toBeTruthy();
+    expect(document.querySelector(".onboarding-model-layout")).toBeTruthy();
+    expect(document.querySelector(".onboarding-model-summary")).toBeTruthy();
+    expect(screen.getByText("让记忆从这里开始")).toBeTruthy();
   });
 
   it("focuses the page title when entering the model substep", async () => {
@@ -181,6 +181,18 @@ describe("OnboardingModelStep", () => {
     );
   });
 
+  it("returns to the visible API key field when it fails in advanced mode", async () => {
+    const p = props();
+    p.advancedOpen = true;
+    p.fieldErrors = { api_key: "请填写 API Key。" };
+    const view = render(<OnboardingModelStep {...p} />);
+    await waitFor(() => expect(p.onAdvancedChange).toHaveBeenCalledWith(false));
+    view.rerender(<OnboardingModelStep {...p} advancedOpen={false} />);
+    await waitFor(() =>
+      expect(document.activeElement).toBe(screen.getByLabelText("API Key")),
+    );
+  });
+
   it("links field errors and keeps secrets out of callback errors", async () => {
     const p = props();
     p.fieldErrors = { api_key: "请填写 API Key。" };

memhub/apps/web/src/OnboardingModelStepNext.tsx

@@ -12,6 +12,7 @@ import type {
 import { useOnboardingTranslation } from "./onboarding-language";
 import { R6ColdStartFrame } from "./R6ColdStartFrame";
 import { R6Button } from "./R6Controls";
+import "./onboarding-model-r6.css";
 
 type Action = "test" | "save-and-enable";
 
@@ -60,6 +61,10 @@ export function OnboardingModelStepNext(props: OnboardingModelStepProps) {
       props.onAdvancedChange(true);
       return;
     }
+    if (firstError === "api_key" && props.advancedOpen) {
+      props.onAdvancedChange(false);
+      return;
+    }
     if (firstError && (!technicalError || props.advancedOpen)) {
       formRef.current
         ?.querySelector<HTMLElement>(`[name="${firstError}"]`)
@@ -173,10 +178,7 @@ export function OnboardingModelStepNext(props: OnboardingModelStepProps) {
           </>
         }
       >
-        <div
-          className="onboarding-model-layout onboarding-model-layout--single-column-600"
-          data-responsive="single-column-600"
-        >
+        <div className="onboarding-model-layout">
           <section
             ref={formRef}
             className="onboarding-model-form"
@@ -184,6 +186,9 @@ export function OnboardingModelStepNext(props: OnboardingModelStepProps) {
             data-advanced={props.advancedOpen}
           >
             <div className="onboarding-model-group">
+              <p className="onboarding-model-intro">
+                {text("选择服务商，填入 API Key。核对已有配置后再继续。")}
+              </p>
               <label
                 className="onboarding-model-field onboarding-model-provider"
                 htmlFor={`${id}-provider`}
@@ -263,16 +268,6 @@ export function OnboardingModelStepNext(props: OnboardingModelStepProps) {
                   )}
                 </strong>
               </div>
-              <div className="onboarding-model-disclosure">
-                <p>
-                  {text("相关对话会发送给所选服务商。")}
-                  {sourceSummary ? ` ${sourceSummary}` : ""}
-                </p>
-                <p>
-                  {text("密钥保存在系统安全存储中，不写入对话或日志。")}{" "}
-                  {text("测试只向此接口发送测试内容，不发送历史对话。")}
-                </p>
-              </div>
               <GenerationTechnicalDisclosure
                 open={props.advancedOpen}
                 disabled={fieldsLocked}
@@ -348,6 +343,35 @@ export function OnboardingModelStepNext(props: OnboardingModelStepProps) {
               ) : null}
             </div>
           </section>
+          <aside
+            className="onboarding-model-summary"
+            aria-label={text("记忆整理")}
+          >
+            <div className="onboarding-model-summary-heading">
+              <p>{text("记忆整理")}</p>
+              <h2>{text("让记忆从这里开始")}</h2>
+            </div>
+            <div className="onboarding-model-connections">
+              <p>{text("对话来源")}</p>
+              <strong>{sourceSummary || text("尚无已选来源")}</strong>
+              <small>
+                {t("onboardingImportedConversations", {
+                  count: props.importedConversationCount ?? 0,
+                })}
+              </small>
+            </div>
+            <div className="onboarding-model-summary-status">
+              <small>
+                {text("处理服务：")}
+                {text(provider?.label ?? "待选择")}
+              </small>
+              <small>
+                {text("相关对话会发送给所选服务商。")}
+                <br />
+                {text("测试只向此接口发送测试内容，不发送历史对话。")}
+              </small>
+            </div>
+          </aside>
         </div>
       </R6ColdStartFrame>
     </div>

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

@@ -48,6 +48,40 @@ it("sizes the import action to its label and wraps footer content", () => {
   );
 });
 
+it("uses content-driven shell, discovery and mode geometry", () => {
+  const stage = declaration("onboarding-r6.css", ".onboarding-r6-stage");
+  const shell = declaration("onboarding-r6.css", ".onboarding-r6-shell");
+  const discovery = declaration(
+    "onboarding-r6.css",
+    ".onboarding-r6-discovery",
+  );
+  const heading = declaration(
+    "onboarding-r6.css",
+    ".onboarding-r6-list-heading",
+  );
+  const mode = declaration("onboarding-r6.css", ".onboarding-r6-mode");
+
+  expect(stage).toMatch(/min-height:\s*0/);
+  expect(stage).not.toMatch(/min-height:\s*852px/);
+  expect(shell).toMatch(/height:\s*100%/);
+  expect(shell).not.toMatch(/(?:^|;)\s*height:\s*820px/);
+  expect(discovery).toMatch(/height:\s*100%/);
+  expect(heading).toMatch(/position:\s*static/);
+  expect(mode).toMatch(/width:\s*100%/);
+});
+
+it("does not reserve an empty eyebrow row", () => {
+  render(
+    <LanguageProvider>
+      <R6ColdStartFrame step={1} title="Fixture" footer={null}>
+        <p>Fixture body</p>
+      </R6ColdStartFrame>
+    </LanguageProvider>,
+  );
+  expect(screen.getByRole("heading", { name: "Fixture" })).toBeTruthy();
+  expect(screen.queryByText("你的记忆，从这里接上")).toBeNull();
+});
+
 it("keeps progress cards content-sized and the step-two footer in normal flow", () => {
   const card = declaration(
     "r6-import-progress.css",
@@ -62,10 +96,10 @@ it("keeps progress cards content-sized and the step-two footer in normal flow",
     ),
   ).toMatch(/flex:\s*0 0 auto/);
   expect(declaration("first-import-r6.css", ".first-import-r6-layout")).toMatch(
-    /height:\s*auto/,
+    /height:\s*100%/,
   );
   expect(
-    declaration("first-import-r6.css", ".first-import-r6-footer-note"),
+    declaration("first-import-r6.css", ".first-import-r6-feedback"),
   ).not.toMatch(/max-height|overflow/);
   expect(declaration("onboarding-r6.css", ".onboarding-r6-body")).toMatch(
     /overflow-y:\s*auto/,

memhub/apps/web/src/R6ColdStartFrame.tsx

@@ -13,7 +13,7 @@ export function R6ColdStartFrame({
 }: {
   step: 1 | 2 | 3;
   title: string;
-  eyebrow: string;
+  eyebrow?: string | null;
   children: ReactNode;
   footer: ReactNode;
   focusToken?: number;
@@ -39,7 +39,7 @@ export function R6ColdStartFrame({
         <section className="onboarding-r6-shell" data-step={step}>
           <header className="onboarding-r6-head">
             <div>
-              <p>{eyebrow}</p>
+              {eyebrow ? <p>{eyebrow}</p> : null}
               <h1
                 ref={titleRef}
                 tabIndex={focusToken === undefined ? undefined : -1}

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

@@ -169,6 +169,7 @@ it("shows the help and diagnostics group by default and hides it when opted out"
   await user.click(screen.getByRole("button", { name: "帮助与诊断" }));
   expect(screen.getByRole("heading", { name: "帮助与诊断" })).toBeTruthy();
   expect(screen.getByRole("heading", { name: "导出日志" })).toBeTruthy();
+  expect(screen.getByText(/可能包含会话正文和本机路径/)).toBeTruthy();
   expect(screen.getByRole("heading", { name: "关于" })).toBeTruthy();
   expect(screen.getByText("1.0.4")).toBeTruthy();
   expect(screen.getByText("8")).toBeTruthy();

memhub/apps/web/src/R6SettingsLayout.test.ts

@@ -9,7 +9,7 @@ function declaration(file: string, selector: string): string {
 
 it("fills settings controls without widening shared fallback controls", () => {
   for (const selector of [
-    ".r6-memory-mode-settings .memory-mode-choice-list",
+    ".r6-memory-mode-settings .memory-mode-cards",
     ".r6-settings .connection-fallback .custom-harness-name",
   ]) {
     const rule = declaration("r6-settings.css", selector);

memhub/apps/web/src/RawConversationGraph3D.test.ts

@@ -0,0 +1,80 @@
+import type {
+  MemoryGraphEdge,
+  MemoryGraphNode,
+  MemoryGraphResponse,
+} from "@one-memory/contracts";
+import { describe, expect, it } from "vitest";
+import { createRawClusterLayout } from "./RawConversationGraph3D";
+
+function makeRawGraph(count: number, sourceCount = 4): MemoryGraphResponse {
+  const sources: MemoryGraphNode[] = Array.from(
+    { length: sourceCount },
+    (_, index) => ({
+      node_id: `source:s-${index}`,
+      node_type: "source",
+      memory_id: null,
+      source_id: `s-${index}`,
+      label: `Source ${index}`,
+      kind: null,
+      status: null,
+      confidence: null,
+    }),
+  );
+  const memories: MemoryGraphNode[] = Array.from(
+    { length: count },
+    (_, index) => ({
+      node_id: `memory:m-${index}`,
+      node_type: "memory",
+      memory_id: `m-${index}`,
+      source_id: null,
+      label: `Turn ${index}`,
+      kind: "chat",
+      status: "confirmed",
+      confidence: null,
+    }),
+  );
+  const edges: MemoryGraphEdge[] = memories.map((memory, index) => ({
+    edge_id: `edge-${index}`,
+    source_node_id: sources[index % sourceCount].node_id,
+    target_node_id: memory.node_id,
+    relation: "evidence_source",
+    origin: "provenance",
+    weight: null,
+  }));
+  return {
+    total_memories: count,
+    projected_memories: count,
+    hy_graph_available: false,
+    nodes: [...sources, ...memories],
+    edges,
+  };
+}
+
+describe("createRawClusterLayout", () => {
+  it.each([1_600, 5_000])(
+    "positions every node in bounded linear time at %i turns",
+    (count) => {
+      const graph = makeRawGraph(count);
+      const started = performance.now();
+      const positions = createRawClusterLayout(graph);
+      const elapsed = performance.now() - started;
+
+      expect(positions.size).toBe(graph.nodes.length);
+      expect(elapsed).toBeLessThan(1_000);
+      for (const position of positions.values()) {
+        expect(Number.isFinite(position.x)).toBe(true);
+        expect(Number.isFinite(position.y)).toBe(true);
+        expect(Number.isFinite(position.z)).toBe(true);
+      }
+    },
+  );
+
+  it("is deterministic", () => {
+    const graph = makeRawGraph(80);
+    const first = createRawClusterLayout(graph);
+    const second = createRawClusterLayout(graph);
+    expect([...first].map(([id, value]) => [id, value.toArray()])).toEqual(
+      [...second].map(([id, value]) => [id, value.toArray()]),
+    );
+  });
+});

memhub/apps/web/src/RawConversationGraph3D.tsx

@@ -0,0 +1,421 @@
+import type {
+  MemoryGraphNode,
+  MemoryGraphResponse,
+} from "@one-memory/contracts";
+import { Focus, Minus, Plus } from "lucide-react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import * as THREE from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { useMemoryLanguage } from "./memory-language";
+
+const GRAPH_CANVAS = 0xedf1f5;
+const MEMORY_COLOR = new THREE.Color(0x4e6478);
+const SELECTED_COLOR = new THREE.Color(0x294355);
+
+/** O(n) deterministic source clusters for the complete lite raw map. */
+export function createRawClusterLayout(
+  graph: MemoryGraphResponse,
+): Map<string, THREE.Vector3> {
+  const positions = new Map<string, THREE.Vector3>();
+  const sources = graph.nodes.filter((node) => node.node_type === "source");
+  const sourceIds = new Set(sources.map((node) => node.node_id));
+  const sourceByMemory = new Map<string, string>();
+  for (const edge of graph.edges) {
+    const sourceId = sourceIds.has(edge.source_node_id)
+      ? edge.source_node_id
+      : sourceIds.has(edge.target_node_id)
+        ? edge.target_node_id
+        : null;
+    if (!sourceId) continue;
+    const memoryId =
+      edge.source_node_id === sourceId
+        ? edge.target_node_id
+        : edge.source_node_id;
+    sourceByMemory.set(memoryId, sourceId);
+  }
+  const fallbackSource = sources[0]?.node_id ?? "source:unknown";
+  const groups = new Map<string, MemoryGraphNode[]>();
+  for (const node of graph.nodes) {
+    if (node.node_type !== "memory") continue;
+    const sourceId = sourceByMemory.get(node.node_id) ?? fallbackSource;
+    const group = groups.get(sourceId) ?? [];
+    group.push(node);
+    groups.set(sourceId, group);
+  }
+  const clusterRing = Math.max(3.5, sources.length * 1.2);
+  sources.forEach((source, sourceIndex) => {
+    const angle = (sourceIndex / Math.max(1, sources.length)) * Math.PI * 2;
+    const center = new THREE.Vector3(
+      Math.cos(angle) * clusterRing,
+      ((sourceIndex % 3) - 1) * 1.4,
+      Math.sin(angle) * clusterRing,
+    );
+    positions.set(source.node_id, center);
+    const memories = groups.get(source.node_id) ?? [];
+    memories.forEach((memory, index) => {
+      const direction = seededDirection(memory.node_id);
+      const radius = 0.9 + Math.cbrt(index + 1) * 0.42;
+      positions.set(
+        memory.node_id,
+        center.clone().addScaledVector(direction, radius),
+      );
+    });
+  });
+  return positions;
+}
+
+export function RawConversationGraph3D({
+  graph,
+  selectedNodeId,
+  onSelectNode,
+}: {
+  graph: MemoryGraphResponse;
+  selectedNodeId: string | null;
+  onSelectNode(node: MemoryGraphNode): void;
+}) {
+  const { text } = useMemoryLanguage();
+  const host = useRef<HTMLDivElement>(null);
+  const selectRef = useRef(onSelectNode);
+  const selectedRef = useRef(selectedNodeId);
+  const graphRef = useRef(graph);
+  const applySelection = useRef<(() => void) | null>(null);
+  const actions = useRef<{
+    zoom(scale: number): void;
+    reset(): void;
+  } | null>(null);
+  const [available, setAvailable] = useState(true);
+  const [hovered, setHovered] = useState<{
+    label: string;
+    x: number;
+    y: number;
+  } | null>(null);
+  selectRef.current = onSelectNode;
+  graphRef.current = graph;
+  const identity = useMemo(
+    () =>
+      `${graph.nodes
+        .map((node) => `${node.node_id}\0${node.label}`)
+        .join("\n")}\n${graph.edges
+        .map(
+          (edge) =>
+            `${edge.edge_id}\0${edge.source_node_id}\0${edge.target_node_id}`,
+        )
+        .join("\n")}`,
+    [graph],
+  );
+
+  useEffect(() => {
+    selectedRef.current = selectedNodeId;
+    applySelection.current?.();
+  }, [selectedNodeId]);
+
+  useEffect(() => {
+    void identity;
+    const graph = graphRef.current;
+    const element = host.current;
+    if (!element) return;
+    let renderer: THREE.WebGLRenderer;
+    try {
+      renderer = new THREE.WebGLRenderer({
+        antialias: true,
+        alpha: true,
+        powerPreference: "high-performance",
+      });
+    } catch {
+      setAvailable(false);
+      return;
+    }
+    setAvailable(true);
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.outputColorSpace = THREE.SRGBColorSpace;
+    renderer.setClearColor(0x000000, 0);
+    element.appendChild(renderer.domElement);
+    renderer.domElement.setAttribute("aria-hidden", "true");
+
+    const scene = new THREE.Scene();
+    scene.fog = new THREE.FogExp2(GRAPH_CANVAS, 0.025);
+    scene.add(new THREE.AmbientLight(0xf2f6fa, 1.8));
+    const directional = new THREE.DirectionalLight(0xe3edf5, 2);
+    directional.position.set(8, 10, 12);
+    scene.add(directional);
+    const camera = new THREE.PerspectiveCamera(48, 1, 0.1, 240);
+    const defaultDistance = Math.max(13, Math.sqrt(graph.nodes.length) * 0.55);
+    camera.position.set(0, defaultDistance * 0.25, defaultDistance);
+    const controls = new OrbitControls(camera, renderer.domElement);
+    controls.enableDamping = false;
+    controls.minDistance = 4;
+    controls.maxDistance = 140;
+
+    const positions = createRawClusterLayout(graph);
+    const nodeById = new Map(graph.nodes.map((node) => [node.node_id, node]));
+    const memories = graph.nodes.filter((node) => node.node_type === "memory");
+    const sources = graph.nodes.filter((node) => node.node_type === "source");
+    const memoryGeometry = new THREE.SphereGeometry(0.14, 10, 8);
+    const memoryMaterial = new THREE.MeshStandardMaterial({
+      color: MEMORY_COLOR,
+      roughness: 0.78,
+      metalness: 0.04,
+      vertexColors: true,
+    });
+    const instances = new THREE.InstancedMesh(
+      memoryGeometry,
+      memoryMaterial,
+      Math.max(1, memories.length),
+    );
+    instances.count = memories.length;
+    const matrix = new THREE.Matrix4();
+    memories.forEach((node, index) => {
+      matrix.setPosition(positions.get(node.node_id) ?? new THREE.Vector3());
+      instances.setMatrixAt(index, matrix);
+      instances.setColorAt(index, MEMORY_COLOR);
+    });
+    instances.instanceMatrix.needsUpdate = true;
+    if (instances.instanceColor) instances.instanceColor.needsUpdate = true;
+    scene.add(instances);
+
+    const sourceGeometry = new THREE.SphereGeometry(0.3, 16, 12);
+    const sourceMeshes = sources.map((node) => {
+      const material = new THREE.MeshStandardMaterial({
+        color: 0x2f6b57,
+        roughness: 0.65,
+      });
+      const mesh = new THREE.Mesh(sourceGeometry, material);
+      mesh.position.copy(positions.get(node.node_id) ?? new THREE.Vector3());
+      mesh.userData.nodeId = node.node_id;
+      scene.add(mesh);
+      return mesh;
+    });
+
+    const edgePositions = new Float32Array(graph.edges.length * 6);
+    graph.edges.forEach((edge, index) => {
+      const start = positions.get(edge.source_node_id);
+      const end = positions.get(edge.target_node_id);
+      if (!start || !end) return;
+      edgePositions.set(
+        [start.x, start.y, start.z, end.x, end.y, end.z],
+        index * 6,
+      );
+    });
+    const edgeGeometry = new THREE.BufferGeometry();
+    edgeGeometry.setAttribute(
+      "position",
+      new THREE.BufferAttribute(edgePositions, 3),
+    );
+    const edgeMaterial = new THREE.LineBasicMaterial({
+      color: 0x91a99c,
+      transparent: true,
+      opacity: 0.24,
+    });
+    scene.add(new THREE.LineSegments(edgeGeometry, edgeMaterial));
+
+    const render = () => renderer.render(scene, camera);
+    const reset = () => {
+      camera.position.set(0, defaultDistance * 0.25, defaultDistance);
+      controls.target.set(0, 0, 0);
+      controls.update();
+      render();
+    };
+    actions.current = {
+      zoom(scale) {
+        const offset = camera.position.clone().sub(controls.target);
+        offset.setLength(
+          Math.max(
+            controls.minDistance,
+            Math.min(controls.maxDistance, offset.length() * scale),
+          ),
+        );
+        camera.position.copy(controls.target).add(offset);
+        controls.update();
+        render();
+      },
+      reset,
+    };
+    applySelection.current = () => {
+      memories.forEach((node, index) => {
+        instances.setColorAt(
+          index,
+          node.node_id === selectedRef.current ? SELECTED_COLOR : MEMORY_COLOR,
+        );
+      });
+      if (instances.instanceColor) instances.instanceColor.needsUpdate = true;
+      for (const mesh of sourceMeshes) {
+        const material = mesh.material as THREE.MeshStandardMaterial;
+        material.color.setHex(
+          mesh.userData.nodeId === selectedRef.current ? 0x294355 : 0x2f6b57,
+        );
+      }
+      render();
+    };
+    applySelection.current();
+
+    const resize = () => {
+      const width = Math.max(1, element.clientWidth);
+      const height = Math.max(1, element.clientHeight);
+      renderer.setSize(width, height, false);
+      camera.aspect = width / height;
+      camera.updateProjectionMatrix();
+      render();
+    };
+    const observer = new ResizeObserver(resize);
+    observer.observe(element);
+    controls.addEventListener("change", render);
+    resize();
+
+    const raycaster = new THREE.Raycaster();
+    const pointer = new THREE.Vector2();
+    let lastRaycast = 0;
+    let pressed: { x: number; y: number; id: number; moved: boolean } | null =
+      null;
+    const hit = (event: PointerEvent) => {
+      const bounds = renderer.domElement.getBoundingClientRect();
+      pointer.x = ((event.clientX - bounds.left) / bounds.width) * 2 - 1;
+      pointer.y = -((event.clientY - bounds.top) / bounds.height) * 2 + 1;
+      raycaster.setFromCamera(pointer, camera);
+      const match = raycaster.intersectObjects(
+        [instances, ...sourceMeshes],
+        false,
+      )[0];
+      if (!match) return null;
+      if (match.object === instances && match.instanceId !== undefined)
+        return memories[match.instanceId] ?? null;
+      return nodeById.get(String(match.object.userData.nodeId)) ?? null;
+    };
+    const move = (event: PointerEvent) => {
+      if (pressed)
+        pressed.moved ||=
+          Math.hypot(event.clientX - pressed.x, event.clientY - pressed.y) > 5;
+      const now = performance.now();
+      if (now - lastRaycast < 50 || pressed) return;
+      lastRaycast = now;
+      const node = hit(event);
+      renderer.domElement.style.cursor = node ? "pointer" : "grab";
+      setHovered(
+        node
+          ? {
+              label: node.label,
+              x: event.clientX - element.getBoundingClientRect().left,
+              y: event.clientY - element.getBoundingClientRect().top,
+            }
+          : null,
+      );
+    };
+    const pointerDown = (event: PointerEvent) => {
+      pressed =
+        event.button === 0
+          ? {
+              x: event.clientX,
+              y: event.clientY,
+              id: event.pointerId,
+              moved: false,
+            }
+          : null;
+    };
+    const select = (event: PointerEvent) => {
+      const start = pressed;
+      pressed = null;
+      if (!start || start.id !== event.pointerId || start.moved) return;
+      const node = hit(event);
+      if (node) selectRef.current(node);
+    };
+    const leave = () => {
+      pressed = null;
+      setHovered(null);
+    };
+    renderer.domElement.addEventListener("pointerdown", pointerDown);
+    renderer.domElement.addEventListener("pointermove", move);
+    renderer.domElement.addEventListener("pointerup", select);
+    renderer.domElement.addEventListener("pointerleave", leave);
+
+    return () => {
+      applySelection.current = null;
+      actions.current = null;
+      observer.disconnect();
+      controls.removeEventListener("change", render);
+      controls.dispose();
+      renderer.domElement.removeEventListener("pointerdown", pointerDown);
+      renderer.domElement.removeEventListener("pointermove", move);
+      renderer.domElement.removeEventListener("pointerup", select);
+      renderer.domElement.removeEventListener("pointerleave", leave);
+      memoryGeometry.dispose();
+      memoryMaterial.dispose();
+      sourceGeometry.dispose();
+      for (const mesh of sourceMeshes)
+        (mesh.material as THREE.Material).dispose();
+      edgeGeometry.dispose();
+      edgeMaterial.dispose();
+      renderer.dispose();
+      renderer.domElement.remove();
+    };
+  }, [identity]);
+
+  return (
+    <div className="memory-graph-canvas" ref={host}>
+      {!available ? (
+        <div className="memory-graph-fallback">
+          <p>{text("这台设备打不开 3D 视图，已显示关联列表。")}</p>
+        </div>
+      ) : (
+        <div
+          className="memory-graph-controls"
+          role="toolbar"
+          aria-label={text("图谱工具")}
+        >
+          <button
+            type="button"
+            className="secondary"
+            aria-label={text("放大图谱")}
+            onClick={() => actions.current?.zoom(0.8)}
+          >
+            <Plus size={16} />
+          </button>
+          <button
+            type="button"
+            className="secondary"
+            aria-label={text("缩小图谱")}
+            onClick={() => actions.current?.zoom(1.25)}
+          >
+            <Minus size={16} />
+          </button>
+          <button
+            type="button"
+            className="secondary"
+            aria-label={text("重置图谱视角")}
+            onClick={() => actions.current?.reset()}
+          >
+            <Focus size={16} />
+          </button>
+        </div>
+      )}
+      {hovered ? (
+        <div
+          className="memory-graph-tooltip"
+          style={{ left: hovered.x + 12, top: Math.max(0, hovered.y - 40) }}
+        >
+          {hovered.label}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+function seededDirection(value: string): THREE.Vector3 {
+  const u = seededUnit(value, 0);
+  const v = seededUnit(value, 1);
+  const theta = u * Math.PI * 2;
+  const z = v * 2 - 1;
+  const radius = Math.sqrt(Math.max(0, 1 - z * z));
+  return new THREE.Vector3(
+    Math.cos(theta) * radius,
+    z,
+    Math.sin(theta) * radius,
+  );
+}
+
+function seededUnit(value: string, salt: number): number {
+  let hash = 2166136261 + salt;
+  for (const character of value) {
+    hash ^= character.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) / 4294967295;
+}

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

@@ -29,6 +29,8 @@ it("shows every role and preserves a long original message in the detail pane",
           messages: [
             { role: "user", content: long },
             { role: "assistant", content: "已收到" },
+            { role: "tool", content: "3 tests passed" },
+            { role: "unknown", content: "来源角色缺失" },
           ],
         }}
         sources={[]}
@@ -38,6 +40,10 @@ it("shows every role and preserves a long original message in the detail pane",
 
   expect(screen.getByText("你")).toBeTruthy();
   expect(screen.getByText("助手")).toBeTruthy();
+  expect(screen.getByText("工具")).toBeTruthy();
+  expect(screen.getByText("作者待核对")).toBeTruthy();
   expect(screen.getByText(long)).toHaveProperty("textContent", long);
   expect(screen.getByText("已收到")).toBeTruthy();
+  expect(screen.queryByText("原始对话")).toBeNull();
+  expect(screen.getByRole("article", { name: "原始对话" })).toBeTruthy();
 });

memhub/apps/web/src/SelectedRawDetail.tsx

@@ -14,6 +14,7 @@ function authorLabel(role: string, t: ReturnType<typeof useGuiLanguage>["t"]) {
   if (role === "user") return t("selectedMemory.author.user");
   if (role === "assistant" || role === "agent")
     return t("selectedMemory.author.agent");
+  if (role === "tool") return t("selectedMemory.author.tool");
   return t("selectedMemory.author.unknown");
 }
 
@@ -46,8 +47,7 @@ export function SelectedRawDetail({
           record.source || t("selectedMemory.sourceUnknown"),
         );
   return (
-    <article className="map-dialogue-reading">
-      <p className="selected-memory-status">{t("memory:原始对话")}</p>
+    <article className="map-dialogue-reading" aria-label={t("memory:原始对话")}>
       <ul className="map-transcript">
         {messages.map((message) => (
           <li key={`${rawRecordId(record)}:${message.role}:${message.content}`}>

memhub/apps/web/src/UltraEvolveScheduleFields.tsx

@@ -0,0 +1,63 @@
+import type { EvolveSchedule } from "@one-memory/contracts";
+import { useId } from "react";
+import { useOnboardingTranslation } from "./onboarding-language";
+import { R6Switch } from "./R6Controls";
+import { TimePicker } from "./TimePicker";
+
+export function UltraEvolveScheduleFields({
+  schedule,
+  headingId,
+  disabled = false,
+  onEnabledChange,
+  onTimeChange,
+}: {
+  schedule: EvolveSchedule;
+  headingId?: string;
+  disabled?: boolean;
+  onEnabledChange(enabled: boolean): void;
+  onTimeChange(time: string): Promise<boolean>;
+}) {
+  const { text } = useOnboardingTranslation();
+  const id = useId();
+  return (
+    <>
+      <div className="r6-evolve-heading">
+        <h3 id={headingId}>{text("记忆整合（Evolve）")}</h3>
+        <p>{text("定期重新整理已有记忆，补充更稳定的关联和结论。")}</p>
+      </div>
+      <div className="r6-evolve-setting">
+        <div className="r6-evolve-setting-copy">
+          <h3>{text("每天自动整合")}</h3>
+          <p>
+            {text(
+              schedule.enabled
+                ? "每天 {time} 左右自动整合，使用这台设备的本地时间；休眠错过后会补跑。"
+                : "已关闭。重新开启后仍按 {time} 运行；已生成的结果会保留。",
+            ).replace("{time}", schedule.time)}
+          </p>
+        </div>
+        <R6Switch
+          label={text("每天自动整合")}
+          checked={schedule.enabled}
+          disabled={disabled}
+          onCheckedChange={onEnabledChange}
+        />
+        {schedule.enabled ? (
+          <div className="r6-evolve-time">
+            <div>
+              <label htmlFor={`${id}-time`}>{text("执行时间")}</label>
+              <p>{text("使用这台设备的本地时间。")}</p>
+            </div>
+            <TimePicker
+              id={`${id}-time`}
+              label={text("执行时间")}
+              value={schedule.time}
+              disabled={disabled}
+              onChange={onTimeChange}
+            />
+          </div>
+        ) : null}
+      </div>
+    </>
+  );
+}

memhub/apps/web/src/api.raw.test.ts

@@ -14,7 +14,7 @@ vi.mock("axios", () => ({
   },
 }));
 
-import { getSdkRaw, searchSdkRaw } from "./api";
+import { getSdkRaw, getSdkRawGraph, searchSdkRaw } from "./api";
 
 beforeEach(() => vi.clearAllMocks());
 
@@ -33,6 +33,8 @@ it("lists raw conversations for the selected application", async () => {
       offset: 20,
       limit: 20,
       unit: "turn",
+      paging: undefined,
+      cursor: undefined,
     },
     signal,
   });
@@ -57,3 +59,36 @@ it("keeps the application filter when searching raw conversations", async () =>
     { signal, timeout: 10_000 },
   );
 });
+
+it("pages the independent lightweight raw graph", async () => {
+  get.mockResolvedValue({
+    data: {
+      user_id: "local",
+      items: [],
+      total: 1_600,
+      offset: 500,
+      limit: 500,
+      has_more: true,
+      snapshot_id: "snapshot-1",
+    },
+  });
+  const signal = new AbortController().signal;
+
+  await getSdkRawGraph({
+    source: "cursor",
+    offset: 500,
+    limit: 500,
+    snapshotId: "snapshot-1",
+    signal,
+  });
+
+  expect(get).toHaveBeenCalledWith("/api/v2/raw/graph", {
+    params: {
+      source: "cursor",
+      offset: 500,
+      limit: 500,
+      snapshot_id: "snapshot-1",
+    },
+    signal,
+  });
+});

memhub/apps/web/src/api.ts

@@ -45,6 +45,7 @@ import {
   type SdkMemoryStatus,
   type SdkMemoryVariant,
   type SdkRawContextItem,
+  type SdkRawGraphPage,
   type SdkRawPage,
   type SourceDirectoryCandidate,
   type SourceImportReceipt,
@@ -987,6 +988,8 @@ export async function getSdkRaw({
   offset = 0,
   limit = 100,
   unit = "turn",
+  paging,
+  cursor,
   signal,
 }: {
   source?: string;
@@ -994,10 +997,40 @@ export async function getSdkRaw({
   offset?: number;
   limit?: number;
   unit?: "raw" | "turn";
+  paging?: "offset" | "cursor";
+  cursor?: string | null;
   signal?: AbortSignal;
 } = {}): Promise<SdkRawPage> {
   const response = await client.get<SdkRawPage>("/api/v2/raw", {
-    params: { source, session_id: sessionId, offset, limit, unit },
+    params: {
+      source,
+      session_id: sessionId,
+      offset,
+      limit,
+      unit,
+      paging,
+      cursor: cursor || undefined,
+    },
+    signal,
+  });
+  return response.data;
+}
+
+export async function getSdkRawGraph({
+  source,
+  offset = 0,
+  limit = 500,
+  snapshotId,
+  signal,
+}: {
+  source?: string;
+  offset?: number;
+  limit?: number;
+  snapshotId?: string;
+  signal?: AbortSignal;
+} = {}): Promise<SdkRawGraphPage> {
+  const response = await client.get<SdkRawGraphPage>("/api/v2/raw/graph", {
+    params: { source, offset, limit, snapshot_id: snapshotId },
     signal,
   });
   return response.data;

memhub/apps/web/src/applications-home.css

@@ -42,6 +42,8 @@
   margin-bottom: 24px;
 }
 .r6-home-overview {
+  display: flex;
+  flex-direction: column;
   min-width: 0;
   min-height: 346px;
   padding: 26px;
@@ -74,6 +76,9 @@
   min-height: 129px;
 }
 .r6-home-metrics > div {
+  display: grid;
+  grid-template-rows: 20px 72px minmax(20px, auto);
+  align-content: start;
   min-width: 0;
   padding: 4px 24px;
   border-right: 1px solid #d5dfe8;
@@ -87,12 +92,16 @@
 .r6-home-metrics p,
 .r6-home-metrics small {
   font-size: 12px;
+  line-height: 20px;
   color: #63707b;
   margin: 0;
 }
+.r6-home-metrics small {
+  display: block;
+}
 .r6-home-figure {
   display: flex;
-  align-items: flex-end;
+  align-items: center;
   gap: 6px;
   margin: 0;
 }
@@ -100,12 +109,10 @@
   font-style: normal;
   font-size: 12px;
   line-height: 20px;
-  padding-bottom: 10px;
   color: #405e75;
 }
 /* Holds the digit slot while the first summary read is in flight, so the 48px
-   type does not spend that frame rendering a word. Height matches the strong
-   below (48px x 1.3). */
+   type does not spend that frame rendering a word. */
 .r6-home-figure-pending {
   display: block;
   width: 92px;
@@ -132,24 +139,25 @@
   animation: none;
 }
 .r6-home-metrics strong {
-  display: block;
+  display: flex;
+  align-items: center;
   font-size: 48px;
   font-weight: 400;
-  line-height: 1.3;
+  line-height: 1;
   color: #405e75;
   font-variant-numeric: tabular-nums;
 }
 .r6-home-metrics strong.r6-home-word {
   font-size: 32px;
-  padding: 14px 0;
+  line-height: 1.25;
   overflow-wrap: anywhere;
 }
 .r6-home-metrics strong.r6-home-time {
   font-size: 34px;
-  line-height: 1.85;
-  padding: 8px 0;
+  line-height: 1.25;
 }
 .r6-home-activity {
+  margin-top: auto;
   border-top: 1px solid #d5dfe8;
   padding-top: 12px;
 }
@@ -278,7 +286,10 @@
   white-space: normal;
 }
 .r6-home-activity small {
+  display: block;
+  margin-top: 4px;
   font-size: 12px;
+  line-height: 18px;
   color: #637786;
 }
 .r6-home-runtime {

memhub/apps/web/src/core-visual.css

@@ -791,6 +791,44 @@ button.rail-button.active::before {
   text-overflow: ellipsis;
   white-space: nowrap;
 }
+.map-pagination:has(.map-load-more) {
+  justify-content: center;
+  padding-top: 8px;
+  border-top: 0;
+}
+.map-load-more {
+  display: grid;
+  width: 32px;
+  height: 32px;
+  padding: 0;
+  place-items: center;
+  border: 1px solid var(--bd);
+  border-radius: 50%;
+  color: var(--tx3);
+  background: var(--surface);
+  transition:
+    color var(--motion-fast) var(--motion-enter),
+    background-color var(--motion-fast) var(--motion-enter),
+    transform var(--motion-fast) var(--motion-enter);
+}
+.map-load-more:hover:not(:disabled) {
+  color: var(--ac-strong);
+  background: var(--ac-bg);
+  transform: translateY(1px);
+}
+.map-load-more:focus-visible {
+  outline: 2px solid var(--ac);
+  outline-offset: 2px;
+}
+.map-load-more svg.loading {
+  animation: map-load-more-pulse 800ms ease-in-out infinite alternate;
+}
+@keyframes map-load-more-pulse {
+  to {
+    transform: translateY(4px);
+    opacity: 0.45;
+  }
+}
 .map-list-status {
   flex: none;
   min-height: 28px;
@@ -829,6 +867,16 @@ button.rail-button.active::before {
 .map-memory-list > li {
   margin-bottom: 4px;
 }
+.map-memory-list.raw > li:not(.map-memory-spacer) {
+  height: 112px;
+}
+.map-memory-list.raw .map-memory-item {
+  height: 112px;
+}
+.map-memory-list > .map-memory-spacer {
+  margin: 0;
+  pointer-events: none;
+}
 .map-memory-item {
   display: grid;
   grid-template-columns: 5px minmax(0, 1fr);

memhub/apps/web/src/first-import-r6.css

@@ -1,8 +1,8 @@
 /* 143:2419/2502/2594/2685: only step2; shared frame/progress are owned elsewhere. */
 .first-import-r6-layout {
-  display: grid;
-  grid-template-columns: minmax(0, 738px) 278px;
-  gap: 30px;
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
   min-height: 100%;
   height: auto;
 }
@@ -13,19 +13,23 @@
   flex-direction: column;
 }
 .first-import-r6-intro {
-  margin: 0;
-  color: #5a6169;
-  font-size: 13px;
-  line-height: 25px;
+  margin: 0 0 8px;
 }
-.first-import-r6-subintro {
-  margin: 1px 0 20px;
+.first-import-r6-intro h2 {
+  margin: 0 0 3px;
+  color: #262a2e;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 26px;
+}
+.first-import-r6-intro p {
+  margin: 0;
   color: #63707b;
   font-size: 12px;
-  line-height: 24px;
+  line-height: 20px;
 }
 .first-import-r6-history-window {
-  margin: -10px 0 12px;
+  margin: 0 0 12px;
   padding: 8px 10px;
   border: 1px solid #ead7a7;
   border-radius: 8px;
@@ -36,10 +40,105 @@
 }
 .first-import-r6-main > .r6-import-progress {
   flex: 0 0 auto;
+  width: 100%;
+  margin-inline: auto;
+}
+.first-import-r6-main > .r6-import-progress[data-count="1"] {
+  width: min(680px, 100%);
+  grid-auto-columns: 100%;
+}
+.first-import-r6-main > .r6-import-progress[data-count="2"] {
+  width: min(720px, 100%);
+  grid-auto-columns: calc((100% - 16px) / 2);
+}
+.first-import-r6-main > .r6-import-progress .r6-import-progress-card {
+  min-height: 112px;
+  padding: 12px 18px;
+  display: grid;
+  grid-template-columns: 82px minmax(0, 1fr);
+  grid-template-rows: auto auto auto;
+  align-content: center;
+  column-gap: 16px;
+  text-align: left;
+}
+.first-import-r6-main > .r6-import-progress .r6-import-progress-orbit {
+  width: 76px;
+  height: 76px;
+  grid-column: 1;
+  grid-row: 1 / 4;
+  margin: 0;
+}
+.first-import-r6-main > .r6-import-progress :is(h2, p, small) {
+  grid-column: 2;
+}
+.first-import-r6-main > .r6-import-progress .r6-import-progress-card h2 {
+  align-self: end;
+}
+.first-import-r6-main > .r6-import-progress[data-count="many"] {
+  grid-auto-flow: row;
+  grid-auto-columns: unset;
+  overflow-x: hidden;
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:not(:has(> :nth-child(4))) {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:has(> :nth-child(4)):not(
+    :has(> :nth-child(5))
+  ) {
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:has(> :nth-child(5)):not(
+    :has(> :nth-child(6))
+  ) {
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:has(> :nth-child(6)):not(
+    :has(> :nth-child(7))
+  ) {
+  grid-template-columns: repeat(6, minmax(0, 1fr));
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:has(> :nth-child(7)) {
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:has(> :nth-child(4))
+  .r6-import-progress-card {
+  min-height: 112px;
+  grid-template-columns: minmax(0, 1fr);
+  justify-items: center;
+  gap: 1px;
+  padding: 8px;
+  text-align: center;
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:has(> :nth-child(4))
+  .r6-import-progress-orbit {
+  width: 54px;
+  height: 54px;
+  grid-column: 1;
+  grid-row: auto;
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:has(> :nth-child(4))
+  :is(h2, p, small) {
+  grid-column: 1;
+  align-self: auto;
+  margin-top: 1px;
+}
+.first-import-r6-main
+  > .r6-import-progress[data-count="many"]:has(> :nth-child(4))
+  .r6-import-progress-icon {
+  width: 36px;
+  height: 36px;
 }
 .first-import-r6-feed {
   flex: 0 0 auto;
-  margin-top: 26px;
+  margin-top: 20px;
   overflow: visible;
   scrollbar-width: thin;
   overscroll-behavior: contain;
@@ -87,9 +186,14 @@
   margin: 0;
 }
 .first-import-r6-options {
+  flex: 1 1 auto;
   min-width: 0;
-  min-height: 0;
-  padding: 24px;
+  min-height: 132px;
+  padding: 22px 24px;
+  display: grid;
+  grid-template-columns: minmax(190px, 0.7fr) minmax(0, 1.3fr);
+  align-items: center;
+  gap: 0 28px;
   border: 1px solid #ffffffe0;
   border-radius: 22px;
   background:
@@ -98,9 +202,13 @@
   box-shadow:
     inset 0 1px #fff,
     0 12px 32px rgb(49 75 101 / 4%);
-  overflow: auto;
+  overflow: visible;
   scrollbar-width: thin;
   overscroll-behavior: contain;
+  align-self: stretch;
+}
+.first-import-r6-options-head {
+  min-width: 0;
 }
 .first-import-r6-eyebrow {
   margin: 0 0 14px;
@@ -127,12 +235,12 @@
   position: relative;
   display: block;
   width: 100%;
-  min-height: 124px;
-  margin: 0 0 16px;
-  padding: 18px 16px 12px;
+  min-height: 104px;
+  margin: 0;
+  padding: 18px 52px 16px 18px;
   border: 1px solid rgb(179 196 209 / 42%);
-  border-radius: 0;
-  background: rgb(255 255 255 / 10%);
+  border-radius: 12px;
+  background: rgb(255 255 255 / 34%);
   box-shadow: inset 0 1px 1px #ffffffd9;
   backdrop-filter: blur(20px);
   cursor: pointer;
@@ -161,8 +269,8 @@
 .first-import-r6-selection input {
   appearance: none;
   position: absolute;
-  top: 22px;
-  right: 18px;
+  top: 20px;
+  right: 20px;
   width: 16px;
   height: 16px;
   min-height: 16px;
@@ -200,10 +308,11 @@
   display: block;
   font-size: 12px;
   line-height: 20px;
-  margin-top: 8px;
+  margin-top: 7px;
   color: #5e6e7a;
 }
 .first-import-r6-options-note {
+  grid-column: 1 / -1;
   font-size: 11px;
   line-height: 22px;
   margin: 0 0 12px;
@@ -223,20 +332,22 @@
 .first-import-r6-options details p {
   margin: 6px 0;
 }
-.first-import-r6-footer-note {
-  flex: 1 1 240px;
-  min-width: 0;
+.first-import-r6-feedback {
+  margin: 0 0 12px;
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: rgb(255 255 255 / 50%);
 }
-.first-import-r6-footer-note p {
+.first-import-r6-feedback p {
   margin: 0;
   font-size: 12px;
   line-height: 20px;
   color: #63707b;
 }
-.first-import-r6-footer-note [role="alert"] {
+.first-import-r6-feedback [role="alert"] {
   color: #944242;
 }
-.first-import-r6-footer-note .first-import-r6-partial-success {
+.first-import-r6-feedback .first-import-r6-partial-success {
   color: #245f50;
   font-weight: 600;
 }
@@ -248,6 +359,7 @@
   flex-wrap: wrap;
   gap: 12px;
   align-items: center;
+  margin-left: auto;
 }
 .first-import-r6-footer-actions > [data-variant="primary"] {
   min-width: min(160px, 100%);
@@ -397,8 +509,7 @@ dialog.first-import-r6-original[open] {
 }
 @media (max-width: 1150px) {
   .first-import-r6-layout {
-    grid-template-columns: minmax(0, 1fr) 278px;
-    gap: 24px;
+    gap: 18px;
   }
 }
 @media (min-width: 761px) and (max-height: 959px) {
@@ -408,12 +519,12 @@ dialog.first-import-r6-original[open] {
     padding-bottom: 16px;
   }
   .first-import-r6-layout {
-    height: auto;
+    height: 100%;
   }
 }
 @media (min-width: 761px) and (max-height: 859px) {
   .first-import-r6-options {
-    padding: 14px;
+    padding: 18px 20px;
     overflow: visible;
   }
   .first-import-r6-eyebrow {
@@ -431,16 +542,16 @@ dialog.first-import-r6-original[open] {
   }
   .first-import-r6-selection,
   .first-import-r6-selection + .first-import-r6-selection {
-    min-height: 86px;
-    margin-bottom: 8px;
-    padding: 9px 12px;
+    min-height: 96px;
+    margin-bottom: 0;
+    padding: 15px 48px 13px 16px;
   }
   .first-import-r6-selection strong {
     line-height: 24px;
   }
   .first-import-r6-selection input {
-    top: 13px;
-    right: 12px;
+    top: 17px;
+    right: 16px;
   }
   .first-import-r6-selection span {
     margin-top: 4px;
@@ -461,6 +572,7 @@ dialog.first-import-r6-original[open] {
     overflow: visible;
   }
   .first-import-r6-options {
+    display: block;
     overflow: visible;
   }
   .first-import-r6-footer-note {

memhub/apps/web/src/memory-mode-cards.css

@@ -0,0 +1,451 @@
+.memory-mode-cards {
+  position: relative;
+  flex: 1;
+  min-width: 0;
+  min-height: 420px;
+  display: flex;
+}
+
+.memory-mode-card-list {
+  flex: 1;
+  min-width: 0;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.memory-mode-card {
+  position: relative;
+  flex: 1 1 0;
+  min-width: 0;
+  min-height: 128px;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  border: 1px solid #c7d3dc;
+  border-radius: 15px;
+  background: rgb(255 255 255 / 66%);
+  color: #304757;
+  box-shadow: inset 0 1px rgb(255 255 255 / 82%);
+  transition:
+    border-color 140ms ease-out,
+    background-color 140ms ease-out,
+    box-shadow 140ms ease-out,
+    transform 140ms ease-out;
+}
+
+.memory-mode-card:has(.memory-mode-card-choice:hover):not(
+  [data-disabled="true"]
+) {
+  border-color: #91a7b6;
+  background: rgb(255 255 255 / 82%);
+  transform: translateY(-1px);
+}
+
+.memory-mode-card[data-selected="true"] {
+  border: 2px solid #6f9183;
+  background: #fbfdfc;
+  box-shadow: 0 10px 26px rgb(47 107 87 / 8%);
+}
+
+.memory-mode-card[data-disabled="true"] {
+  opacity: 0.55;
+}
+
+.memory-mode-card-choice {
+  position: relative;
+  min-height: 0;
+  height: 100%;
+  padding: 18px 20px;
+  display: grid;
+  grid-template-columns: minmax(230px, 0.85fr) minmax(0, 1.45fr);
+  grid-template-rows: auto auto minmax(0, 1fr);
+  column-gap: 28px;
+  align-items: center;
+  cursor: pointer;
+}
+
+.memory-mode-card[data-disabled="true"] .memory-mode-card-choice {
+  cursor: default;
+}
+
+.memory-mode-card-choice > input {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.memory-mode-card:has(input:focus-visible) {
+  outline: 2px solid var(--r6-focus, #557c93);
+  outline-offset: 3px;
+}
+
+.memory-mode-title {
+  grid-column: 1;
+  grid-row: 1;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding-right: 34px;
+}
+
+.memory-mode-index {
+  flex: 0 0 auto;
+  color: var(--ok, #2f6b57);
+  font-size: 11px;
+  font-variant-numeric: tabular-nums;
+  letter-spacing: 0.06em;
+}
+
+.memory-mode-title strong {
+  min-width: 0;
+  color: #263947;
+  font-size: 19px;
+  font-weight: 600;
+  line-height: 28px;
+}
+
+.memory-mode-tier {
+  flex: 0 0 auto;
+  color: var(--ok, #2f6b57);
+  font-size: 11px;
+  font-weight: 650;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+}
+
+.memory-mode-current {
+  flex: 0 0 auto;
+  padding: 1px 6px;
+  border-radius: 999px;
+  color: #526a60;
+  background: #edf4f0;
+  font-size: 10px;
+  line-height: 17px;
+}
+
+.memory-mode-radio {
+  position: absolute;
+  top: 18px;
+  right: 20px;
+  width: 21px;
+  height: 21px;
+  flex: 0 0 21px;
+  display: grid;
+  place-items: center;
+  border: 1px solid #8da0ae;
+  border-radius: 6px;
+  color: #fff;
+  background: rgb(255 255 255 / 82%);
+}
+
+.memory-mode-card[data-selected="true"] .memory-mode-radio {
+  border-color: var(--ok, #2f6b57);
+  background: var(--ok, #2f6b57);
+}
+
+.memory-mode-radio svg {
+  stroke: #fff;
+  stroke-width: 2;
+}
+
+.memory-mode-description {
+  grid-column: 1;
+  grid-row: 2;
+  align-self: start;
+  min-height: 0;
+  margin-top: 6px;
+  color: #526674;
+  font-size: 13px;
+  line-height: 22px;
+  text-wrap: pretty;
+}
+
+.memory-mode-features {
+  grid-column: 2;
+  grid-row: 1 / -1;
+  align-self: stretch;
+  margin-top: 0;
+  padding: 0 42px 0 28px;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  align-content: center;
+  gap: 8px;
+  border-left: 1px solid #dbe4ea;
+  color: #5e6e7a;
+  font-size: 12px;
+  line-height: 19px;
+}
+
+.memory-mode-features > span {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+}
+
+.memory-mode-features i {
+  width: 5px;
+  height: 5px;
+  margin-top: 7px;
+  flex: 0 0 5px;
+  border-radius: 50%;
+  background: #7f95a4;
+}
+
+.memory-mode-detail {
+  grid-column: 1;
+  grid-row: 3;
+  align-self: start;
+  margin-top: 6px;
+  padding: 7px 0 0;
+  display: flex;
+  align-items: flex-start;
+  gap: 7px;
+  border-top: 1px solid #d4e0e7;
+  background: transparent;
+  color: #405867;
+  font-size: 11px;
+  line-height: 17px;
+  animation: memory-mode-detail-in 180ms ease-out both;
+}
+
+.memory-mode-detail > svg {
+  margin-top: 1px;
+  flex: 0 0 auto;
+}
+
+.memory-mode-detail > div {
+  min-width: 0;
+  flex: 1;
+}
+
+.memory-mode-cards--grid {
+  flex: none;
+  min-height: 0;
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 16px;
+  align-items: start;
+}
+
+.memory-mode-cards--grid .memory-mode-card-list {
+  display: contents;
+}
+
+.memory-mode-cards--grid .memory-mode-card {
+  position: static;
+  flex: none;
+  min-height: 286px;
+  height: auto;
+}
+
+.memory-mode-cards--grid .memory-mode-card-choice {
+  position: static;
+  min-height: 284px;
+  height: auto;
+  padding: 20px;
+  display: flex;
+  flex-direction: column;
+}
+
+.memory-mode-cards--grid .memory-mode-title {
+  width: 100%;
+  padding-right: 0;
+}
+
+.memory-mode-cards--grid .memory-mode-radio {
+  position: static;
+  margin-left: auto;
+}
+
+.memory-mode-cards--grid .memory-mode-description {
+  min-height: 50px;
+  margin-top: 10px;
+}
+
+.memory-mode-cards--grid .memory-mode-features {
+  width: 100%;
+  margin-top: auto;
+  padding: 16px 0 2px;
+  border-top: 1px solid #dbe4ea;
+  border-left: 0;
+}
+
+.memory-mode-cards--grid .memory-mode-detail {
+  width: calc(100% + 40px);
+  margin: auto -20px -20px;
+  padding: 14px 18px;
+  display: block;
+  border-radius: 0 0 15px 15px;
+  background: #f1f6f8;
+  font-size: 12px;
+  line-height: 20px;
+}
+
+.memory-mode-cards--grid .memory-mode-detail > svg {
+  display: none;
+}
+
+@keyframes memory-mode-detail-in {
+  from {
+    opacity: 0;
+    transform: translateY(-4px);
+  }
+}
+
+@media (min-width: 761px) and (max-height: 959px) {
+  .memory-mode-cards--rows {
+    min-height: 360px;
+  }
+  .memory-mode-cards--rows .memory-mode-card-list {
+    gap: 12px;
+  }
+  .memory-mode-cards--rows .memory-mode-card {
+    min-height: 112px;
+  }
+  .memory-mode-cards--rows .memory-mode-card-choice {
+    min-height: 0;
+    padding: 13px 16px;
+    grid-template-columns: minmax(205px, 0.82fr) minmax(0, 1.5fr);
+    column-gap: 22px;
+  }
+  .memory-mode-cards--rows .memory-mode-radio {
+    top: 13px;
+    right: 16px;
+  }
+  .memory-mode-cards--rows .memory-mode-title strong {
+    font-size: 17px;
+    line-height: 25px;
+  }
+  .memory-mode-cards--rows .memory-mode-description {
+    min-height: 0;
+    margin-top: 4px;
+    font-size: 12px;
+    line-height: 18px;
+  }
+  .memory-mode-cards--rows .memory-mode-features {
+    margin-top: 0;
+    padding: 0 36px 0 22px;
+    gap: 6px;
+    font-size: 11px;
+    line-height: 17px;
+  }
+  .memory-mode-cards--rows .memory-mode-detail {
+    margin-top: 5px;
+    padding: 5px 0 0;
+    gap: 6px;
+    font-size: 11px;
+    line-height: 16px;
+  }
+}
+
+@media (max-width: 760px) {
+  .memory-mode-cards--rows {
+    flex: none;
+    min-height: 0;
+  }
+  .memory-mode-cards--rows .memory-mode-card-list {
+    display: grid;
+    grid-template-columns: 1fr;
+  }
+  .memory-mode-cards--rows .memory-mode-card {
+    flex: none;
+    min-height: 0;
+    height: auto;
+  }
+  .memory-mode-cards--rows .memory-mode-card-choice {
+    height: auto;
+    min-height: 0;
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+  }
+  .memory-mode-cards--rows .memory-mode-radio {
+    position: static;
+    margin-left: auto;
+  }
+  .memory-mode-cards--rows .memory-mode-title {
+    width: 100%;
+    padding-right: 0;
+  }
+  .memory-mode-cards--rows .memory-mode-description {
+    min-height: 0;
+    margin-top: 8px;
+  }
+  .memory-mode-cards--rows .memory-mode-features {
+    width: 100%;
+    margin-top: 16px;
+    padding: 16px 0 0;
+    border-top: 1px solid #dbe4ea;
+    border-left: 0;
+  }
+  .memory-mode-cards--rows .memory-mode-detail {
+    width: calc(100% + 40px);
+    margin: 16px -20px -20px;
+    padding: 14px 20px 16px;
+    border-radius: 0 0 15px 15px;
+    background: #f1f6f8;
+  }
+}
+
+@media (min-width: 681px) and (max-height: 959px) {
+  .memory-mode-cards--grid {
+    gap: 14px;
+  }
+  .memory-mode-cards--grid .memory-mode-card {
+    min-height: 194px;
+  }
+  .memory-mode-cards--grid .memory-mode-card-choice {
+    min-height: 194px;
+    padding: 16px;
+  }
+  .memory-mode-cards--grid .memory-mode-title strong {
+    font-size: 17px;
+    line-height: 25px;
+  }
+  .memory-mode-cards--grid .memory-mode-description {
+    min-height: 36px;
+    margin-top: 8px;
+    font-size: 12px;
+    line-height: 20px;
+  }
+  .memory-mode-cards--grid .memory-mode-features {
+    padding-top: 10px;
+    gap: 6px;
+    font-size: 11px;
+    line-height: 18px;
+  }
+  .memory-mode-cards--grid .memory-mode-detail {
+    width: calc(100% + 32px);
+    margin: auto -16px -16px;
+    padding: 10px 14px;
+    font-size: 11px;
+    line-height: 18px;
+  }
+}
+
+@media (max-width: 680px) {
+  .memory-mode-cards--grid {
+    grid-template-columns: 1fr;
+  }
+  .memory-mode-cards--grid .memory-mode-card,
+  .memory-mode-cards--grid .memory-mode-card-choice {
+    min-height: 0;
+  }
+  .memory-mode-cards--grid .memory-mode-description {
+    min-height: 0;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .memory-mode-card,
+  .memory-mode-detail {
+    animation: none;
+    transition: none;
+  }
+}

memhub/apps/web/src/memory-mode-ui.tsx

@@ -0,0 +1,232 @@
+import type { MemoryModePlan, MemoryPipelineMode } from "@one-memory/contracts";
+import { useEffect, useRef } from "react";
+import { useOnboardingTranslation } from "./onboarding-language";
+import { R6Button } from "./R6Controls";
+
+export const MODE_COPY: Record<
+  MemoryPipelineMode,
+  { title: string; description: string }
+> = {
+  lite: {
+    title: "基础记忆（lite）",
+    description: "保存原始对话 · 不调用生成模型 · 搜索原始会话",
+  },
+  pro: {
+    title: "智能记忆（pro）",
+    description: "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆",
+  },
+  ultra: {
+    title: "深度记忆（ultra）",
+    description: "智能记忆 + 知识图谱 · 可自动 Evolve · 增强关联召回",
+  },
+};
+
+export const BLOCKER_COPY: Record<MemoryModePlan["blockers"][number], string> =
+  {
+    active_model_required: "使用 pro 或 ultra 前需要先配置并启用生成模型。",
+    embedding_maintenance_in_progress:
+      "正在检查或切换向量模型，完成后才能切换记忆模式。",
+    memory_lifecycle_busy: "记忆维护正在进行，完成后才能切换模式。",
+    graph_store_unavailable: "当前安装缺少知识图谱组件，无法开启 ultra。",
+  };
+
+export function memoryModePlanRows(plan: MemoryModePlan) {
+  const rows = [
+    {
+      label: "新对话",
+      content:
+        plan.capabilities.content_plane === "raw"
+          ? "之后只保存原始对话，不再生成新记忆。"
+          : plan.capabilities.graph_enabled
+            ? "新对话会整理成记忆并写入知识图谱。"
+            : "新对话会由模型整理成记忆。",
+    },
+    {
+      label: "模型调用与费用",
+      content: plan.capabilities.generation_required
+        ? plan.capabilities.evolve_available
+          ? "会调用当前生成模型；自动整合可能产生额外费用。切换本身不会立即整合。"
+          : "会调用当前生成模型，可能产生服务商费用。"
+        : "不调用生成模型，不再产生这部分费用。",
+    },
+    {
+      label: "搜索范围",
+      content:
+        plan.capabilities.content_plane === "raw"
+          ? "切换后搜索原始对话。"
+          : plan.capabilities.graph_enabled
+            ? "搜索沉淀记忆，并用知识图谱补充关联。"
+            : "搜索沉淀后的记忆。",
+    },
+  ];
+  if (plan.effects.includes("earlier_raw_not_extracted"))
+    rows.push({
+      label: "已有数据",
+      content: "已经处理完的旧对话不会补做；原始对话全部保留。",
+    });
+  if (plan.effects.includes("higher_mode_memories_hidden"))
+    rows.push({
+      label: "已有数据",
+      content:
+        plan.effective_target === "pro"
+          ? "普通沉淀记忆仍可使用；深度记忆新增的更高层记忆和图谱数据继续保留，但在智能记忆下不显示、不参与召回。原始对话不会删除。"
+          : "已有记忆继续保留，但在基础记忆下不显示、不参与召回；原始对话不会删除。",
+    });
+  if (plan.effects.includes("existing_memories_added_to_graph"))
+    rows.push({
+      label: "知识图谱",
+      content: "已有记忆会在后台加入知识图谱，期间仍可使用。",
+    });
+  if (plan.effects.includes("evolve_stopped"))
+    rows.push({
+      label: "每天自动整合",
+      content: "每天自动整合会停止，已经生成的数据不会删除。",
+    });
+  if (plan.capabilities.evolve_available)
+    rows.push({
+      label: "切换后",
+      content: "可设置每天自动整合时间，也可以随时立即整合一次。",
+    });
+  return rows;
+}
+
+export function MemoryModeConfirmDialog({
+  mode,
+  plan,
+  busy,
+  error,
+  opener,
+  allowedBlockers = [],
+  onCancel,
+  onConfirm,
+}: {
+  mode: MemoryPipelineMode;
+  plan: MemoryModePlan;
+  busy: boolean;
+  error?: string;
+  opener?: HTMLElement | null;
+  allowedBlockers?: readonly MemoryModePlan["blockers"][number][];
+  onCancel(): void;
+  onConfirm(): void;
+}) {
+  const { text } = useOnboardingTranslation();
+  const panel = useRef<HTMLElement>(null);
+  const busyRef = useRef(busy);
+  const onCancelRef = useRef(onCancel);
+  busyRef.current = busy;
+  onCancelRef.current = onCancel;
+  const blocking = plan.blockers.filter(
+    (blocker) => !allowedBlockers.includes(blocker),
+  );
+
+  useEffect(() => {
+    const element = panel.current;
+    if (!element) return;
+    const inertSiblings = new Map<HTMLElement, boolean>();
+    let branch: HTMLElement = element.parentElement ?? element;
+    while (branch.parentElement) {
+      for (const sibling of branch.parentElement.children) {
+        if (!(sibling instanceof HTMLElement) || sibling === branch) continue;
+        inertSiblings.set(sibling, sibling.inert);
+        sibling.inert = true;
+      }
+      branch = branch.parentElement;
+      if (branch === document.body) break;
+    }
+    const controls = () =>
+      Array.from(
+        element.querySelectorAll<HTMLElement>("button:not(:disabled)"),
+      );
+    controls()[0]?.focus();
+    const handleKey = (event: KeyboardEvent) => {
+      if (event.key === "Escape" && !busyRef.current) {
+        event.preventDefault();
+        onCancelRef.current();
+        return;
+      }
+      if (event.key !== "Tab") return;
+      const items = controls();
+      const first = items[0];
+      const last = items.at(-1);
+      if (!first || !last) {
+        event.preventDefault();
+        element.focus();
+      } else if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault();
+        last.focus();
+      } else if (!event.shiftKey && document.activeElement === last) {
+        event.preventDefault();
+        first.focus();
+      }
+    };
+    element.addEventListener("keydown", handleKey);
+    return () => {
+      element.removeEventListener("keydown", handleKey);
+      for (const [sibling, wasInert] of inertSiblings) sibling.inert = wasInert;
+      if (opener?.isConnected) opener.focus();
+    };
+  }, [opener]);
+
+  useEffect(() => {
+    if (busy) panel.current?.focus();
+  }, [busy]);
+
+  return (
+    <div className="r6-settings-dialog-layer" role="presentation">
+      <section
+        ref={panel}
+        className="r6-settings-dialog r6-mode-confirm-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="memory-mode-confirm-title"
+        tabIndex={-1}
+      >
+        <h2 id="memory-mode-confirm-title">
+          {text("切换到 {mode}？").replace(
+            "{mode}",
+            text(MODE_COPY[mode].title),
+          )}
+        </h2>
+        <dl className="r6-mode-confirm-effects">
+          {memoryModePlanRows(plan).map((row) => (
+            <div key={`${row.label}:${row.content}`}>
+              <dt>{text(row.label)}</dt>
+              <dd>{text(row.content)}</dd>
+            </div>
+          ))}
+        </dl>
+        {plan.blockers.map((blocker) => (
+          <p
+            className={
+              blocking.includes(blocker)
+                ? "r6-settings-error"
+                : "r6-settings-note"
+            }
+            role={blocking.includes(blocker) ? "alert" : "status"}
+            key={blocker}
+          >
+            {text(BLOCKER_COPY[blocker])}
+          </p>
+        ))}
+        {error ? (
+          <p className="r6-settings-error" role="alert">
+            {text(error)}
+          </p>
+        ) : null}
+        <footer>
+          <R6Button disabled={busy} onClick={onCancel}>
+            {text("取消")}
+          </R6Button>
+          <R6Button
+            variant="primary"
+            pending={busy}
+            disabled={blocking.length > 0}
+            onClick={onConfirm}
+          >
+            {text("切换模式")}
+          </R6Button>
+        </footer>
+      </section>
+    </div>
+  );
+}

memhub/apps/web/src/model-profile-readiness.test.ts

@@ -0,0 +1,79 @@
+import type { ModelProbeResult, ModelProfile } from "@one-memory/contracts";
+import { expect, it } from "vitest";
+import { modelProfileReady, profileFromProbe } from "./model-profile-readiness";
+
+const profile: ModelProfile = {
+  profile_id: "saved-1",
+  name: "Saved model",
+  provider_kind: "openai_compatible",
+  base_url: "https://models.example/v1",
+  model: "model-1",
+  embedding_model: null,
+  embedding_provider_kind: null,
+  embedding_base_url: null,
+  embedding_dimensions: null,
+  context_window: null,
+  disable_thinking: false,
+  has_api_key: true,
+  timeout_seconds: 60,
+  max_concurrency: 1,
+  revision: 1,
+  is_active: false,
+  created_at: "2026-09-14T00:00:00Z",
+  updated_at: "2026-09-14T00:00:00Z",
+  capabilities: {
+    endpoint_reachable: false,
+    model_available: false,
+    embedding_available: false,
+    structured_output: false,
+  },
+};
+
+function probe(
+  inputRevision: number | null | undefined = 1,
+  outputRevision = 2,
+): ModelProbeResult {
+  return {
+    profile_id: profile.profile_id,
+    input_profile_revision: inputRevision,
+    profile_revision: outputRevision,
+    stages: [],
+    capabilities: {
+      endpoint_reachable: true,
+      model_available: true,
+      embedding_available: true,
+      structured_output: false,
+    },
+  };
+}
+
+it("accepts a measured one-revision bump before or after profile refresh", () => {
+  const receipt = probe();
+  const beforeRefresh = profileFromProbe(profile, receipt);
+  const afterRefresh = profileFromProbe({ ...profile, revision: 2 }, receipt);
+
+  expect(beforeRefresh).toMatchObject({ revision: 2 });
+  expect(afterRefresh).toMatchObject({ revision: 2 });
+  expect(modelProfileReady(beforeRefresh as ModelProfile, receipt)).toBe(true);
+});
+
+it("rejects a bump without input evidence, a skipped revision and another profile", () => {
+  expect(profileFromProbe(profile, probe(null, 2))).toBeNull();
+  expect(profileFromProbe(profile, probe(1, 3))).toBeNull();
+  expect(
+    profileFromProbe(profile, {
+      ...probe(),
+      profile_id: "another-profile",
+    }),
+  ).toBeNull();
+});
+
+it("keeps unavailable credentials from becoming ready", () => {
+  const receipt = probe();
+  const tested = profileFromProbe(
+    { ...profile, credential_state: "unavailable" },
+    receipt,
+  );
+  expect(tested).not.toBeNull();
+  expect(modelProfileReady(tested as ModelProfile, receipt)).toBe(false);
+});

memhub/apps/web/src/model-profile-readiness.ts

@@ -0,0 +1,48 @@
+import type { ModelProbeResult, ModelProfile } from "@one-memory/contracts";
+
+export function profileFromProbe(
+  profile: ModelProfile,
+  probe: ModelProbeResult | null | undefined,
+): ModelProfile | null {
+  if (!probe || probe.profile_id !== profile.profile_id) return null;
+  const inputRevision = probe.input_profile_revision;
+  if (!Number.isSafeInteger(probe.profile_revision)) return null;
+  if (inputRevision === undefined || inputRevision === null) {
+    if (probe.profile_revision !== profile.revision) return null;
+  } else {
+    if (
+      !Number.isSafeInteger(inputRevision) ||
+      (probe.profile_revision !== inputRevision &&
+        probe.profile_revision !== inputRevision + 1) ||
+      (profile.revision !== inputRevision &&
+        profile.revision !== probe.profile_revision)
+    )
+      return null;
+  }
+  return {
+    ...profile,
+    revision: probe.profile_revision,
+    capabilities: probe.capabilities,
+  };
+}
+
+export function modelProfileReady(
+  profile: ModelProfile,
+  probe: ModelProbeResult | null = null,
+  error: string | null = null,
+): boolean {
+  return (
+    !error &&
+    (!probe ||
+      (probe.profile_id === profile.profile_id &&
+        probe.profile_revision === profile.revision &&
+        probe.capabilities.endpoint_reachable &&
+        probe.capabilities.model_available &&
+        probe.capabilities.embedding_available)) &&
+    profile.credential_state !== "unavailable" &&
+    !(profile.has_configured_api_key && !profile.has_api_key) &&
+    profile.capabilities.endpoint_reachable &&
+    profile.capabilities.model_available &&
+    profile.capabilities.embedding_available
+  );
+}

memhub/apps/web/src/model-setup-next.css

@@ -134,6 +134,11 @@
   background: transparent;
   color: #4e6478;
 }
+.model-settings .generation-technical-toggle:hover:not(:disabled) {
+  border-color: transparent;
+  background: #e9f0f4;
+  color: #304757;
+}
 .model-settings .generation-technical-fields {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));

memhub/apps/web/src/onboarding-model-r6.css

@@ -588,49 +588,44 @@
   transition: none;
 }
 
-/* Generation-only cold start. Embedding remains a separate settings lane. */
-.onboarding-model-r6 .onboarding-r6-head > div {
-  width: min(760px, 100%);
-}
-.onboarding-model-layout {
-  display: block;
-  width: min(760px, 100%);
-  height: auto;
-  margin-inline: auto;
-}
-.onboarding-model-form {
-  overflow: visible;
-}
+/* The current controller keeps generation-only behavior. The presentation
+   intentionally returns to the original open-source setup composition:
+   an open form column, a separate context column, and a distinct advanced state. */
 .onboarding-model-group {
-  display: grid;
-  gap: 20px;
-  padding: 24px;
-  border: 1px solid #d8e2e8;
-  border-radius: 14px;
-  background: #fff;
+  display: block;
 }
-.onboarding-model-provider,
-.onboarding-model-key {
-  margin-top: 0;
+.onboarding-model-group > .onboarding-model-intro {
+  margin-bottom: 0;
 }
-.onboarding-model-field {
-  gap: 7px;
-}
-.onboarding-model-field :is(input, select),
 .onboarding-model-field .om-option-menu-button,
 .generation-model-field :is(input, select) {
   width: 100%;
   min-width: 0;
-  height: 44px;
-  padding: 9px 12px;
-  border: 1px solid #c8d3db;
+  height: 54px;
+  padding: 12px 16px;
+  border: 1px solid #c0ccd5;
   border-radius: 8px;
-  background: #fff;
+  background: #f0f5f6;
   color: #262a2e;
   font:
-    400 14px / 22px "Noto Sans SC",
+    400 14px / 23px "Noto Sans SC",
     "PingFang SC",
     sans-serif;
+  transition:
+    border-color var(--r6-fast, 140ms),
+    background-color var(--r6-fast, 140ms);
+}
+.onboarding-model-field .om-option-menu-button:hover:not(:disabled),
+.generation-model-field :is(input, select):hover:not(:disabled) {
+  border-color: #9fb6ad;
+  background: #eaf1f2;
+}
+.generation-model-field select:not(:disabled),
+.generation-technical-toggle:not(:disabled) {
+  cursor: pointer;
+}
+:is(.onboarding-model-field, .generation-model-field) [aria-invalid="true"] {
+  border-color: #a24646;
 }
 .onboarding-model-field small,
 .generation-model-field small {
@@ -641,11 +636,8 @@
 .onboarding-model-default-summary {
   display: grid;
   gap: 6px;
-  padding: 14px 0;
-  border-block: 1px solid #e4eaee;
-}
-.onboarding-model-default-summary span,
-.onboarding-model-disclosure {
+  min-height: 54px;
+  margin-top: 12px;
   color: #63707b;
   font-size: 12px;
   line-height: 20px;
@@ -655,100 +647,131 @@
   font-size: 14px;
   font-weight: 600;
 }
-.onboarding-model-disclosure {
-  display: grid;
-  gap: 6px;
-}
 .generation-technical-disclosure {
-  border-top: 1px solid #e4eaee;
-  padding-top: 4px;
+  margin-top: 23px;
 }
 .generation-technical-toggle {
   display: flex;
   width: 100%;
-  min-height: 44px;
+  min-height: 28px;
   align-items: center;
   justify-content: space-between;
-  padding: 8px 0;
+  padding: 0;
   border: 0;
+  border-radius: 6px;
   background: transparent;
   color: #4e6478;
   font:
     500 13px / 21px "Noto Sans SC",
     "PingFang SC",
     sans-serif;
+  transition:
+    background-color var(--r6-fast, 140ms),
+    color var(--r6-fast, 140ms);
+}
+.generation-technical-toggle:hover:not(:disabled) {
+  background: #ffffff66;
+  color: #33424d;
 }
 .generation-technical-fields {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
-  gap: 16px;
-  padding-top: 12px;
-}
-.generation-model-field {
-  display: grid;
-  min-width: 0;
-  gap: 6px;
-  color: #63707b;
-  font-size: 12px;
-  line-height: 20px;
-}
-.generation-model-field:has([name="base-url"]),
-.generation-runtime-fields,
-.generation-thinking {
-  grid-column: 1 / -1;
-}
-.generation-runtime-fields {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 12px;
+  gap: 19px 30px;
+  margin-top: 34px;
 }
 .generation-technical-fields[hidden] {
   display: none;
 }
-.generation-runtime-note {
+.generation-model-field {
+  display: grid;
+  min-width: 0;
+  gap: 5px;
+  color: #63707b;
+  font-size: 12px;
+  line-height: 20px;
+}
+.generation-model-field:has([name="base_url"]),
+.generation-runtime-fields,
+.generation-runtime-note,
+.generation-thinking {
   grid-column: 1 / -1;
+}
+.generation-model-field :is(input, select) {
+  height: 42px;
+  padding: 9px 12px;
+  font-size: 13px;
+  line-height: 21px;
+}
+.generation-runtime-fields {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 24px;
+}
+.generation-runtime-note {
   color: #63707b;
   font-size: 12px;
   line-height: 19px;
 }
 .generation-thinking {
   display: flex;
-  min-height: 32px;
+  min-height: 28px;
   align-items: center;
-  gap: 9px;
+  gap: 10px;
   color: #416e5c;
-  font-size: 13px;
+  font-size: 14px;
+  line-height: 23px;
 }
-.generation-model-error {
-  color: #a24646 !important;
+.onboarding-model-r6 .generation-model-error {
+  color: #a24646;
 }
-.onboarding-model-recovery-actions {
-  margin-top: 12px;
+.onboarding-model-form[data-advanced="true"]
+  :is(
+    .onboarding-model-intro,
+    .onboarding-model-provider,
+    .onboarding-model-key,
+    .onboarding-model-default-summary
+  ) {
+  display: none;
 }
+.onboarding-model-form[data-advanced="true"] .generation-technical-disclosure {
+  margin-top: 0;
+}
+.onboarding-model-form[data-advanced="true"] .generation-technical-toggle {
+  min-height: 28px;
+}
+.onboarding-model-recovery-actions,
 .onboarding-model-feedback {
   margin-top: 8px;
 }
 @media (min-width: 761px) {
-  .onboarding-model-r6 .onboarding-r6-body {
+  .onboarding-model-group {
+    flex: 1;
+    min-height: 0;
     overflow-y: auto;
-  }
-  .onboarding-model-form {
-    display: block;
-    overflow: visible;
+    overscroll-behavior: contain;
+    scrollbar-width: thin;
+    scrollbar-gutter: stable;
+    scroll-padding: 12px;
+    padding-inline: 4px 16px;
   }
 }
-@media (max-width: 600px) {
-  .onboarding-model-layout--single-column-600 .onboarding-model-group {
-    padding: 16px;
-    border-radius: 10px;
+@media (min-width: 761px) and (max-height: 959px) {
+  .onboarding-model-form[data-advanced="false"]
+    .onboarding-model-field
+    :is(input, select, .om-option-menu-button) {
+    height: 44px;
+    padding-top: 8px;
+    padding-bottom: 8px;
   }
-  .onboarding-model-layout--single-column-600 .generation-technical-fields,
-  .onboarding-model-layout--single-column-600 .generation-runtime-fields {
+  .generation-technical-fields {
+    margin-top: 16px;
+  }
+}
+@media (max-width: 760px) {
+  .generation-technical-fields,
+  .generation-runtime-fields {
     grid-template-columns: minmax(0, 1fr);
-  }
-  .onboarding-model-footer-actions .r6-button,
-  .onboarding-model-footer-actions .r6-button[data-variant="primary"] {
-    flex-basis: 100%;
+    gap: 12px;
   }
 }
 @media (prefers-reduced-motion: reduce) {

memhub/apps/web/src/onboarding-r6.css

@@ -115,14 +115,16 @@
 }
 .onboarding-r6-stage {
   flex: 1;
-  min-height: 852px;
-  padding: 32px 24px 2px;
+  min-height: 0;
+  display: flex;
+  padding: 24px;
 }
 .onboarding-r6-shell {
   min-height: 0;
   width: 1120px;
   max-width: 100%;
-  height: 820px;
+  height: 100%;
+  max-height: 820px;
   margin: 0 auto;
   display: flex;
   flex-direction: column;
@@ -137,7 +139,7 @@
     inset 0 -1px 0 #adc0d22e;
 }
 .onboarding-r6-head {
-  min-height: 123.7px;
+  min-height: 0;
   flex: 0 0 auto;
   display: flex;
   flex-wrap: wrap;
@@ -195,6 +197,7 @@
   background: #ffffff38;
   display: flex;
   align-items: center;
+  justify-content: flex-end;
   gap: 16px;
   border-radius: 0 0 25px 25px;
 }
@@ -222,29 +225,39 @@
     overscroll-behavior: contain;
     scrollbar-width: thin;
   }
+  .onboarding-r6-body:has(> .onboarding-r6-mode) {
+    padding-block: 14px;
+    overflow-y: auto;
+  }
+  .onboarding-r6-mode {
+    width: 100%;
+    gap: 12px;
+  }
+  .onboarding-r6-mode-intro h2 {
+    font-size: 20px;
+    line-height: 28px;
+  }
+  .onboarding-r6-mode-intro p {
+    font-size: 12px;
+    line-height: 20px;
+  }
 }
 .onboarding-r6-discovery {
-  height: 560.2px;
+  height: 100%;
+  min-height: 0;
   display: grid;
   grid-template-columns: minmax(0, 738px) 278px;
   gap: 30px;
 }
 .onboarding-r6-apps {
-  position: relative;
   min-width: 0;
-}
-.onboarding-r6-intro {
-  margin: 0;
-  font-size: 13px;
-  line-height: 24.05px;
-  color: #5a6169;
-}
-.onboarding-r6-intro p {
-  margin: 0;
+  min-height: 0;
+  display: grid;
+  grid-template-rows: auto minmax(0, 1fr);
+  gap: 12px;
 }
 .onboarding-r6-list-heading {
-  position: absolute;
-  inset: 96px 0 auto;
+  position: static;
   height: 30px;
   display: flex;
   align-items: center;
@@ -277,8 +290,10 @@
   cursor: default;
 }
 .onboarding-r6-list-area {
-  position: absolute;
-  inset: 142px 0 auto;
+  position: static;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
 }
 .onboarding-r6-list-status .onboarding-r6-quiet:disabled {
   color: #4e6478;
@@ -288,7 +303,9 @@
   padding: 0;
   margin: 0;
   list-style: none;
-  height: 330px;
+  min-height: 0;
+  height: auto;
+  flex: 1;
   display: flex;
   flex-direction: column;
   gap: 12px;
@@ -451,44 +468,6 @@
   content: "↓";
   margin-right: 6px;
 }
-.onboarding-r6-import {
-  position: absolute;
-  top: 498px;
-  left: 0;
-  right: 0;
-  display: flex;
-  align-items: center;
-  gap: 10px;
-  font-size: 12px;
-  color: #6a7988;
-}
-/* 143:2085 puts 导入历史包 first and the "没有本机历史？" sentence after it; the
-   markup keeps the sentence first so it stays the accessible label order for
-   the control that follows. Reordering visually only, rather than moving the
-   DOM, keeps that reading order intact. */
-.onboarding-r6-import > p {
-  order: 2;
-}
-.onboarding-r6-import > .history-import,
-.onboarding-r6-import > .history-import-trigger {
-  order: 1;
-}
-.onboarding-r6-import > p {
-  margin: 0;
-}
-.onboarding-r6-import .history-import-trigger {
-  font: inherit;
-  border: 0;
-  border-radius: 0;
-  background: transparent;
-  color: #4e6478;
-  padding: 5px 11px;
-  min-height: 30px;
-  box-shadow: none;
-}
-.onboarding-r6-import .history-import-trigger > svg {
-  display: none;
-}
 .onboarding-r6-summary {
   border-radius: 22px;
   border: 1px solid #ffffffe0;
@@ -500,6 +479,8 @@
   display: flex;
   flex-direction: column;
   gap: 11px;
+  align-self: stretch;
+  min-height: 0;
 }
 .onboarding-r6-summary p {
   margin: 0;
@@ -572,45 +553,78 @@
   border: 0;
 }
 .onboarding-r6-mode {
-  width: min(720px, 100%);
-  margin: 0 auto;
+  width: 100%;
+  margin: 0;
   display: flex;
   flex-direction: column;
-  gap: 20px;
+  gap: 16px;
 }
 .onboarding-r6-mode-intro {
-  text-align: center;
+  text-align: left;
+}
+.onboarding-r6-mode-intro h2 {
+  margin: 0;
+  color: #263947;
+  font-size: 22px;
+  line-height: 32px;
 }
 .onboarding-r6-mode-intro p {
-  margin: 0;
+  margin: 4px 0 0;
   color: #637381;
   font-size: 14px;
   line-height: 22px;
 }
-.onboarding-r6-mode .memory-mode-choice-list {
-  background: rgb(255 255 255 / 72%);
+.onboarding-r6-ultra-default {
+  display: grid;
+  gap: 2px;
 }
-.onboarding-r6-mode .memory-mode-choice {
-  min-height: 82px;
-  padding: 15px 18px;
+.onboarding-r6-ultra-default strong {
+  color: #304757;
+  font-size: 12px;
+  font-weight: 600;
 }
-.onboarding-r6-mode .memory-mode-choice-copy {
-  gap: 4px;
+.onboarding-r6-ultra-default small {
+  color: #607482;
+  font-size: 11px;
+  line-height: 18px;
 }
-.onboarding-r6-mode .memory-mode-choice-copy strong {
-  font-size: 16px;
-  line-height: 25px;
+.onboarding-r6-evolve-settings {
+  margin-top: 0;
+  padding: 18px 20px 4px;
+  border: 1px solid #cfdae2;
+  border-radius: 12px;
+  background: rgb(255 255 255 / 58%);
 }
-.onboarding-r6-mode .memory-mode-choice-copy small {
+.onboarding-r6-evolve-settings .r6-evolve-heading {
+  margin-bottom: 2px;
+}
+.onboarding-r6-evolve-settings .r6-evolve-setting {
+  grid-template-columns: minmax(0, 1fr) auto;
+  padding-bottom: 12px;
+  border-bottom: 0;
+}
+.onboarding-r6-evolve-settings .r6-evolve-setting-copy {
+  min-width: 0;
+}
+.onboarding-r6-evolve-settings .r6-evolve-time {
+  grid-template-columns: minmax(0, 1fr) 180px;
+}
+.onboarding-r6-evolve-settings .r6-evolve-time label {
+  color: #304757;
   font-size: 13px;
+  font-weight: 600;
   line-height: 22px;
 }
-.onboarding-r6-mode-ultra-note {
-  margin: -6px 0 0;
-  color: #637381;
-  font-size: 12px;
+.onboarding-r6-schedule-recovery {
+  display: grid;
+  justify-items: center;
+  gap: 10px;
+  color: #944242;
+  font-size: 13px;
   line-height: 20px;
-  text-align: center;
+}
+.onboarding-r6-schedule-recovery p {
+  margin: 0;
 }
 .onboarding-r6-mode-error {
   min-height: 20px;
@@ -620,6 +634,12 @@
   font-size: 13px;
   line-height: 20px;
 }
+@media (min-width: 761px) {
+  .onboarding-r6-mode {
+    min-height: 100%;
+    gap: 24px;
+  }
+}
 .onboarding-r6-empty {
   margin: 0;
   padding: 28px 18px;
@@ -763,17 +783,11 @@
     flex-direction: column;
   }
   .onboarding-r6-apps {
-    min-height: 590px;
+    min-height: 0;
   }
-  .onboarding-r6-list-heading {
-    top: 110px;
-  }
-  .onboarding-r6-list-area {
-    top: 154px;
-  }
-  .onboarding-r6-import {
-    top: 552px;
-    flex-wrap: wrap;
+  .onboarding-r6-list {
+    height: min(330px, 45vh);
+    flex: none;
   }
   .onboarding-r6-row > label {
     padding: 14px 10px;
@@ -815,20 +829,7 @@
   }
   .onboarding-r6-discovery > .onboarding-r6-apps {
     min-height: 0;
-    display: grid;
-    grid-template-columns: minmax(0, 1fr);
-    grid-template-rows: auto 30px minmax(0, 1fr) auto;
-    gap: 12px;
-  }
-  .onboarding-r6-apps > .onboarding-r6-list-heading,
-  .onboarding-r6-apps > .onboarding-r6-list-area,
-  .onboarding-r6-apps > .onboarding-r6-import {
-    position: static;
-    min-height: 0;
-  }
-  .onboarding-r6-apps > .onboarding-r6-list-area {
-    display: flex;
-    flex-direction: column;
+    grid-template-rows: auto minmax(0, 1fr);
   }
   .onboarding-r6-list-area > .onboarding-r6-list {
     min-height: 0;

memhub/apps/web/src/r6-settings.css

@@ -227,10 +227,27 @@
   font-size: 13px;
   line-height: 22px;
 }
-.r6-memory-mode-settings .memory-mode-choice-list {
+.r6-memory-mode-settings .memory-mode-cards {
   width: 100%;
   max-width: none;
 }
+.r6-memory-mode-settings
+  .memory-mode-card[data-mode="ultra"][data-selected="true"] {
+  grid-column: 1 / -1;
+}
+.r6-memory-mode-settings
+  .memory-mode-card[data-mode="ultra"][data-selected="true"]
+  .memory-mode-card-choice {
+  min-height: 180px;
+}
+.r6-evolve-settings--in-card {
+  margin: 0;
+  padding: 0;
+  border-top: 0;
+}
+.r6-evolve-settings--in-card .r6-evolve-setting:last-child {
+  border-bottom: 0;
+}
 .r6-settings-note {
   margin: 14px 0 0;
   padding: 10px 12px;

memhub/apps/web/src/sdk-raw-map.ts

@@ -1,13 +1,17 @@
 import type {
   GovernedMemory,
   MemoryDetail,
+  MemoryGraphResponse,
   MemoryLibraryPage,
   SdkRawContextItem,
+  SdkRawGraphItem,
   SdkRawPage,
   SdkRawRecord,
+  SourceResponse,
 } from "@one-memory/contracts";
 
 export type RawMapRecord = SdkRawRecord | SdkRawContextItem;
+export const SDK_RAW_PAGE_SIZE = 50;
 
 export function rawRecordId(record: RawMapRecord): string {
   return record.turn_id || record.raw_id;
@@ -72,6 +76,11 @@ function pageFor(
   total: number,
   offset: number,
   limit: number,
+  cursor?: {
+    next_cursor?: string | null;
+    has_more?: boolean;
+    total_exact?: boolean;
+  },
 ): MemoryLibraryPage {
   const sourceIds: Record<string, string[]> = {};
   const sourceTime: Record<
@@ -97,6 +106,7 @@ function pageFor(
     total,
     offset,
     limit,
+    ...cursor,
     source_ids_by_memory: sourceIds,
     source_time_by_memory: sourceTime,
     search_window: null,
@@ -107,13 +117,89 @@ function pageFor(
 }
 
 export function rawLibraryPage(page: SdkRawPage): MemoryLibraryPage {
-  return pageFor(page.items, page.total, page.offset, page.limit);
+  return pageFor(page.items, page.total, page.offset, page.limit, {
+    next_cursor: page.next_cursor,
+    has_more: page.has_more,
+    total_exact: page.total_exact,
+  });
 }
 
 export function rawSearchPage(items: SdkRawContextItem[]): MemoryLibraryPage {
   return pageFor(items, items.length, 0, Math.max(items.length, 1));
 }
 
+export function rawGraphRecord(item: SdkRawGraphItem): SdkRawContextItem {
+  return {
+    kind: "raw",
+    raw_id: item.raw_id,
+    turn_id: item.turn_id,
+    content: item.label,
+    source: item.source,
+    session_id: item.session_id,
+    memory_at:
+      typeof item.memory_at === "number"
+        ? new Date(item.memory_at * 1_000).toISOString()
+        : null,
+    score: 0,
+    truncated: true,
+  };
+}
+
+export function rawGraphProjection(
+  items: SdkRawGraphItem[],
+  total: number,
+  sources: SourceResponse[],
+): MemoryGraphResponse {
+  const labels = new Map(
+    sources.map((source) => [source.source_id, source.display_name]),
+  );
+  const nodes = [];
+  const edges = [];
+  const sourceIds = new Set<string>();
+  for (const item of items) {
+    const sourceId = item.source || "default";
+    if (!sourceIds.has(sourceId)) {
+      sourceIds.add(sourceId);
+      nodes.push({
+        node_id: `source:${sourceId}`,
+        node_type: "source" as const,
+        memory_id: null,
+        source_id: sourceId,
+        label: labels.get(sourceId) ?? sourceId,
+        kind: null,
+        status: null,
+        confidence: null,
+      });
+    }
+    const nodeId = `memory:${item.turn_id}`;
+    nodes.push({
+      node_id: nodeId,
+      node_type: "memory" as const,
+      memory_id: item.turn_id,
+      source_id: null,
+      label: item.label,
+      kind: "chat",
+      status: "confirmed",
+      confidence: null,
+    });
+    edges.push({
+      edge_id: `source:${sourceId}->${nodeId}`,
+      source_node_id: `source:${sourceId}`,
+      target_node_id: nodeId,
+      relation: "evidence_source",
+      origin: "provenance" as const,
+      weight: null,
+    });
+  }
+  return {
+    total_memories: total,
+    projected_memories: items.length,
+    hy_graph_available: false,
+    nodes,
+    edges,
+  };
+}
+
 export function rawDetail(record: RawMapRecord): MemoryDetail {
   const memory = rawMapMemory(record);
   return {

memhub/apps/web/src/use-import-sources.test.tsx

@@ -129,7 +129,7 @@ function ColdIntentHarness() {
 }
 
 describe("useImportSources", () => {
-  it("queries an uncertain cold-start intent before trying another write", async () => {
+  it("recovers an uncertain cold-start write from its durable receipt immediately", async () => {
     connectSources.mockRejectedValueOnce(new Error("response lost"));
     getSourceConnection.mockImplementation(async (requestId: string) => ({
       request_id: requestId,
@@ -142,11 +142,11 @@ describe("useImportSources", () => {
     const button = screen.getByRole("button", { name: "start cold import" });
     await waitFor(() => expect(button).toHaveProperty("disabled", false));
     await userEvent.click(button);
-    await userEvent.click(button);
-    expect(connectSources).toHaveBeenCalledTimes(1);
+    await waitFor(() => expect(getSourceConnection).toHaveBeenCalledOnce());
     const sent = connectSources.mock.calls[0][2];
     expect(sent.sourceRoots).toEqual({ cursor: "root:v2:fixture" });
     expect(getSourceConnection).toHaveBeenCalledWith(sent.requestId);
+    expect(connectSources).toHaveBeenCalledTimes(1);
   });
   it("translates a source error code without exposing a generic HTTP failure", async () => {
     const reason = Object.assign(
@@ -434,6 +434,7 @@ describe("useImportSources", () => {
       expect(stored).not.toContain("authorized");
       expect(stored).not.toContain("~/.fixture");
       first.unmount();
+      getSourceConnection.mockClear();
       getHealth.mockResolvedValue(health(instance));
       getSourceConnection.mockResolvedValue(receipt(requestId, ["ok"]));
       const next = await controller();
@@ -639,7 +640,9 @@ describe("useImportSources", () => {
     let currentSource = { ...source("ok"), grant_revision: 1 };
     const saved = new Map<string, ConnectSourcesResponse>();
     getSources.mockImplementation(async () => [currentSource]);
-    getSourceConnection.mockImplementation(async (id: string) => saved.get(id));
+    getSourceConnection
+      .mockRejectedValueOnce(new Error("receipt temporarily offline"))
+      .mockImplementation(async (id: string) => saved.get(id));
     connectSources.mockImplementation(async (ids: string[], _, options) => {
       saved.set(options.requestId, receipt(options.requestId, ids));
       currentSource = { ...currentSource, authorized: true, grant_revision: 2 };
@@ -854,6 +857,7 @@ describe("useImportSources", () => {
 
   it("recovers an uncertain failed-only retry after remount without replaying accepted sources", async () => {
     const saved = new Map<string, ConnectSourcesResponse>();
+    let loseRetryReceiptOnce = true;
     connectSources.mockImplementation(async (ids: string[], _, options) => {
       const response =
         ids.length === 2
@@ -863,7 +867,17 @@ describe("useImportSources", () => {
       if (ids.length === 1) throw new Error("retry response lost");
       return response;
     });
-    getSourceConnection.mockImplementation(async (id: string) => saved.get(id));
+    getSourceConnection.mockImplementation(async (id: string) => {
+      const known = saved.get(id);
+      if (
+        loseRetryReceiptOnce &&
+        known?.accepted_source_ids.includes("failed")
+      ) {
+        loseRetryReceiptOnce = false;
+        throw new Error("retry receipt temporarily offline");
+      }
+      return known;
+    });
     const first = await controller();
     const snapshot = [source("ok"), source("failed")];
     await act(async () => {

memhub/apps/web/src/use-import-sources.ts

@@ -159,39 +159,53 @@ export function useImportSources(_options: { automaticSync?: boolean } = {}) {
         });
       }
       submitted = true;
-      const result = await connectSourceSet([
-        [...ids],
-        true,
-        {
-          fullRescan: checked.onboarding,
-          onboarding: checked.onboarding,
-          enableSync: true,
-          requestId: id,
-          ...(traceId ? { traceId } : {}),
-          ...(checked.importUploadId === undefined
-            ? {}
-            : { importUploadId: checked.importUploadId }),
-          sourceRoots: Object.fromEntries(
-            checked.sources
-              .filter((source) => ids.includes(source.source_id))
-              .map((source) => [source.source_id, source.candidate_root_id]),
-          ),
-          ...(checked.sources.some(
-            (source) => (source.candidate_revision ?? 0) > 0,
-          )
-            ? {
-                sourceCandidateRevisions: Object.fromEntries(
-                  checked.sources
-                    .filter((source) => ids.includes(source.source_id))
-                    .map((source) => [
-                      source.source_id,
-                      source.candidate_revision ?? 0,
-                    ]),
-                ),
-              }
-            : {}),
-        },
-      ]);
+      let result: ConnectSourcesResponse;
+      try {
+        result = await connectSourceSet([
+          [...ids],
+          true,
+          {
+            fullRescan: checked.onboarding,
+            onboarding: checked.onboarding,
+            enableSync: true,
+            requestId: id,
+            ...(traceId ? { traceId } : {}),
+            ...(checked.importUploadId === undefined
+              ? {}
+              : { importUploadId: checked.importUploadId }),
+            sourceRoots: Object.fromEntries(
+              checked.sources
+                .filter((source) => ids.includes(source.source_id))
+                .map((source) => [source.source_id, source.candidate_root_id]),
+            ),
+            ...(checked.sources.some(
+              (source) => (source.candidate_revision ?? 0) > 0,
+            )
+              ? {
+                  sourceCandidateRevisions: Object.fromEntries(
+                    checked.sources
+                      .filter((source) => ids.includes(source.source_id))
+                      .map((source) => [
+                        source.source_id,
+                        source.candidate_revision ?? 0,
+                      ]),
+                  ),
+                }
+              : {}),
+          },
+        ]);
+      } catch (reason) {
+        // Core persists the idempotent receipt before it finishes activating
+        // every source lane. A large cold start can therefore commit and keep
+        // working after the POST's 30s transport deadline. Read the receipt
+        // before surfacing an unknown result; never replay the write here.
+        if (isDefiniteAccessRefusal(reason)) throw reason;
+        try {
+          result = await getSourceConnection(id);
+        } catch {
+          throw reason;
+        }
+      }
       assertConnectionReceipt(result, id, ids);
       liveRequests.current.set(id, {
         instanceId: fresh.instance_id,

memhub/apps/web/src/use-model-profiles.test.ts

@@ -318,22 +318,38 @@ it("records a failed test only for the attempted revision and rejects a mismatch
   expect(result.current.profiles[0].capabilities).toEqual(profile.capabilities);
 });
 
-it("shows a probe-induced new revision only after the matching profile refresh", async () => {
+it("commits a probe-induced revision before the follow-up refresh returns", async () => {
   vi.mocked(api.getModelProfiles).mockResolvedValueOnce([profile]);
   const { result } = renderHook(useModelProfiles);
   await waitFor(() => expect(result.current.profiles).toHaveLength(1));
-  const updated = { ...profile, revision: 2, embedding_dimensions: 512 };
+  const updated = {
+    ...profile,
+    revision: 2,
+    embedding_dimensions: 512,
+    capabilities: {
+      ...profile.capabilities,
+      endpoint_reachable: true,
+      model_available: true,
+      embedding_available: true,
+    },
+  };
+  const receipt = {
+    ...probeResult(updated),
+    input_profile_revision: profile.revision,
+  };
   const delayed = deferred<ModelProfile[]>();
   vi.mocked(api.getModelProfiles).mockReturnValueOnce(delayed.promise);
-  vi.mocked(api.probeModelProfile).mockResolvedValueOnce(probeResult(updated));
+  vi.mocked(api.probeModelProfile).mockResolvedValueOnce(receipt);
   await act(async () => {
     await result.current.probeProfile(profile.profile_id);
   });
-  expect(result.current.probeFor(profile)).toBeNull();
+  expect(result.current.profiles[0]).toMatchObject({
+    revision: 2,
+    capabilities: receipt.capabilities,
+  });
+  expect(result.current.probeFor(result.current.profiles[0])).toEqual(receipt);
   await act(async () => {
     delayed.resolve([updated]);
   });
-  expect(result.current.probeFor(result.current.profiles[0])).toEqual(
-    probeResult(updated),
-  );
+  expect(result.current.probeFor(result.current.profiles[0])).toEqual(receipt);
 });

memhub/apps/web/src/use-model-profiles.ts

@@ -19,6 +19,7 @@ import {
   updateModelProfile,
 } from "./api";
 import { modelErrorText } from "./model-error-text";
+import { profileFromProbe } from "./model-profile-readiness";
 import {
   clearPendingModelCreation,
   readPendingModelCreation,
@@ -314,12 +315,7 @@ export function useModelProfiles() {
           })]: result,
         }));
         setProfiles((previous) =>
-          previous.map((item) =>
-            item.profile_id === result.profile_id &&
-            item.revision === result.profile_revision
-              ? { ...item, capabilities: result.capabilities }
-              : item,
-          ),
+          previous.map((item) => profileFromProbe(item, result) ?? item),
         );
       },
       (reason) =>

memhub/docs/ARCHITECTURE.md

@@ -139,6 +139,14 @@ This exception does not extend to VDB, Coding, prompt, reconcile, or lifecycle.
 - 旧用户迁移：由 App 在可见的启动 loading 阶段统一执行；此时 Core 尚未对外提供产品读写。所有已发布版本都先经 SDK 写入，Governance/Evidence 只是镜像，所以迁移**不复制任何 memory 或 raw**：创建并校验完整 bundle、让写入队列脱离旧表、把旧版命名的 SDK 向量集合接回当前名字、用 Runtime 同样配置的公开 SDK client 按 ID 回读核对，通过后才提交 marker、删除旧表。由一个 Core 命令 `sdk-migrate` 完成；Desktop 启动与 CLI `memhub install`/`upgrade`（macOS、Linux）在启动新 Runtime 前调用它，普通用户不需要另跑命令。App 不得在 migration `deferred` 状态继续启动 Runtime。
 - 迁移期间宿主 capture hook 由 Desktop 活跃 PID marker 静默挡住，不再追加
   Evidence；cutover 后先从宿主 History checkpoint 补齐遗漏 turn，再恢复 live sync。
+- 宿主 capture hook（`one-memory capture <host>`）是短命的独立进程，**不打开主库**：
+  它只读 runtime receipt 与 runtime token，把 hook JSON 经 loopback
+  `POST /api/v1/live-capture/{source}` 交给正在运行的 Core，超时或 Core 未运行即静默丢弃，
+  不回退本地写；迁移 fence 仍在 hook 侧检查。Core 在进程内套用其余的门（grant、sync、
+  拒绝计数、自动化会话、cursor/claude 去重），再按 live file sync 的同一路径
+  （`materialize_write_input` → `stage_sdk_input` → `finalize_sdk_file`，live 优先级）
+  经单一 writer 入队。live sync 已读取其宿主文件的来源，hook 内容交给文件路径，
+  同一 turn 只进 SDK 一次；只有没有文件轮询的来源才从 hook 入队。
 - Matter 若未来重新开发，需以新的 SDK-native 合同重新设计，不继承当前占位 schema。
 
 Pinned SDK 版本见发布锁文件 / `MEMORY.md`（随发布更新）。

memhub/docs/INSTALLATION.md

@@ -1,6 +1,6 @@
 # MemHub 安装与发行
 
-MemHub `v1.0.6`（build 41）的发行目标如下：
+MemHub `v1.0.6`（build 43）的发行目标如下：
 
 | 平台 | 发行物 | 构建与验收 |
 | --- | --- | --- |

memhub/docs/PRODUCT_LOG_TROUBLESHOOTING.md

@@ -10,9 +10,10 @@
 新增受限标量标签，仍应按私人数据处理，不能直接对外发送。`debug` 会让 HY 的
 `hy_memory.log` 记录 DEBUG 行，其中可能包含完整 prompt/response 和获授权的对话正文。
 
-排查时只通过 App 的“导出日志”提供文件：导出过程会按安全白名单重新生成诊断事件，不会打包
-原始日志。不要直接发送 `diagnostic-*.jsonl`、整个 `~/.one-memory` 数据目录或 debug 级别的
-`hy_memory.log`；后者如确需分享，必须由开发人员另行确认并脱敏。
+App 的“导出日志”会同时打包安全投影和 `~/.one-memory/logs/` 下的完整运行日志，供可信开发人员
+还原本机故障。原始日志可能包含会话正文和本机路径，发送前必须确认接收方；不要公开分享，也不要
+发送整个 `~/.one-memory` 数据目录。SDK 的 debug 级 `hy_memory.log` 不在该 ZIP 中；如确需分享，
+必须由开发人员另行确认并脱敏。只需要脱敏事件时使用 `memhub logs export`。
 
 ## 1. Log level 设什么
 
@@ -41,8 +42,8 @@ debug 可能把完整模型 prompt/response 写入本机调试日志，不得长
 
 ## 2. 日志在哪里
 
-App 内推荐直接使用“运行诊断 → 导出日志”。开发人员远程指导时，优先使用
-`memhub logs`，它会再次过滤不安全字段。原始结构化日志只用于本机现场查看，不得作为附件发送。
+App 内推荐直接使用“运行诊断 → 导出日志”，它会生成包含完整运行日志的 ZIP。开发人员远程指导
+且不需要原始日志时，优先使用 `memhub logs`，它会过滤不安全字段。不要手工打包整个数据目录。
 Core 日志默认位于：
 
 ```text

memhub/docs/contracts/diagnostic-logging.md

@@ -45,13 +45,18 @@ host-bridge、desktop 和 cli。单文件 4 MiB，保留 3 份轮转；额外清
 读取器只枚举上述固定文件名的 regular file，不跟随符号链接，不接受任意路径。日常本地查询
 遇到损坏行时跳过并计数，不让一行损坏遮蔽其余证据。
 
-导出是独立的安全边界：它重新读取并校验全部候选事件，只把明确列入导出白名单的字段投影为
+CLI 导出是独立的安全边界：它重新读取并校验全部候选事件，只把明确列入导出白名单的字段投影为
 新的 `diagnostics/events.jsonl`；details 不只检查 key，还按字段约束 value 类型，并拒绝自由文本、
-路径和凭证形态的字符串。绝不复制原始 `diagnostic-*.jsonl`、普通运行日志或崩溃报告。
-导出包还可以包含固定 schema 的系统摘要和问题时间点，但不接受调用方传入的任意对象展开。
+路径和凭证形态的字符串。CLI 不复制原始日志或崩溃报告。
+
+Desktop 设置页的“导出日志”用于开发人员排查本机运行故障。除上述安全投影和状态摘要外，它还会
+把 One Memory Home 的 `logs/` 目录中全部普通文件及轮转文件放入 ZIP 的 `logs/` 目录。它不跟随
+符号链接、不递归读取其他目录，也不包含数据库、SDK 数据目录或系统崩溃报告。原始日志可能包含
+会话正文、本机路径或其他私人信息，ZIP 的 README 必须明确提示只发送给可信的开发人员。
+
 任何事件、marker、安全投影或日志目录读取失败时，导出必须 fail-closed：删除临时文件、不发布
-诊断包，更不能回退为打包原始日志。发布使用已设好权限的临时文件原子创建最终目标，已存在的
-目标不得覆盖，发布后也不存在再 chmod 失败留下伪成功文件的窗口。
+诊断包。发布使用已设好权限的临时文件原子创建最终目标，已存在的目标不得覆盖，发布后也不存在
+再 chmod 失败留下伪成功文件的窗口。
 
 ## 覆盖与节流
 

memhub/docs/contracts/memory-mode-evolve-v1.md

@@ -412,16 +412,18 @@ mode. A change rebuilds the SDK handles the same way. Contract:
 
 The App's product rules are:
 
-- A new installation explicitly chooses lite or pro. Choosing lite persists
-  the mode and completes onboarding without a generation model. Choosing pro
-  opens model setup and completes onboarding only after activation succeeds.
+- A new installation explicitly chooses lite, pro or ultra. Choosing lite
+  persists the mode and completes onboarding without a generation model.
+  Choosing pro or ultra opens model setup when no model is active and completes
+  onboarding only after activation succeeds.
 - Lite always ingests authorized imported and live conversations into L1 raw,
   even when model sedimentation is paused. That pause controls generation-model
   work in pro/ultra; it never turns raw conversation storage off.
 - Existing installations keep the default pro behaviour; an absent
   `memory_mode` is never inferred from model availability.
-- Ultra is enabled only from Settings. Its nightly schedule is on by default
-  at 03:00 local time, and Settings also exposes a manual evolve action.
+- Ultra's nightly schedule is configured during first-run selection or later
+  from Settings. It is on by default at 03:00 local time. Settings also exposes
+  a manual evolve action; onboarding does not run evolve immediately.
 - The memory page shows raw conversations in lite and advanced memories in
   pro/ultra. Higher-mode memories remain stored while lite is active but are
   neither shown nor served by lite search.

memhub/package.json

@@ -2,7 +2,7 @@
   "name": "one-memory",
   "version": "1.0.6",
   "release": {
-    "build_number": 41,
+    "build_number": 43,
     "macos_min_version": "13.0",
     "app_update": "manual",
     "runtime_manifest_schema": 1,

memhub/packages/contracts/src/index.ts

@@ -259,7 +259,7 @@ export interface ConnectSourcesResponse {
   request_id?: string | null;
 }
 
-export type OnboardingModeIntent = "lite" | "pro";
+export type OnboardingModeIntent = "lite" | "pro" | "ultra";
 export type OnboardingSetupStep = "review" | "mode" | "model";
 
 export interface OnboardingProgressUpdate {
@@ -510,6 +510,10 @@ export interface MemoryLibraryPage {
   total: number;
   offset: number;
   limit: number;
+  /** Cursor paging: opaque continuation for a page whose exact total is not read. */
+  next_cursor?: string | null;
+  has_more?: boolean;
+  total_exact?: boolean;
   /** Active evidence sources for each returned memory, from the same authorized page snapshot. */
   source_ids_by_memory?: Record<string, string[]>;
   /** When each returned memory's cited conversation happened (D96). `import`
@@ -709,10 +713,34 @@ export interface SdkRawPage {
   limit: number;
   offset: number;
   unit?: "raw" | "turn";
+  next_cursor?: string | null;
+  has_more?: boolean;
+  total_exact?: boolean;
   /** A time range was applied to this page in Core (the SDK list has none). */
   time_filtered?: boolean;
 }
 
+/** Lightweight complete-map projection. Raw text remains SDK-owned. */
+export interface SdkRawGraphItem {
+  turn_id: string;
+  raw_id: string;
+  label: string;
+  source: string;
+  session_id: string;
+  memory_at: number | null;
+  gmt_created: number | null;
+}
+
+export interface SdkRawGraphPage {
+  user_id: string;
+  items: SdkRawGraphItem[];
+  total: number;
+  limit: number;
+  offset: number;
+  has_more: boolean;
+  snapshot_id: string;
+}
+
 /** `GET /api/v2/memory-library/layers`: memories per SDK layer. */
 export interface SdkLayerCounts {
   /** The user whose memories were counted. */

memhub/packages/host-bridge/src/capture-hooks.ts

@@ -1,8 +1,9 @@
 /** Register `capture` on the hosts whose one-click install can own a hook file.
  *
  * The command is the packaged core binary. It reads the hook's JSON on stdin
- * and writes visible text into Evidence. Stdout stays empty, so the host does
- * not treat the capture as another instruction.
+ * and hands it to the running Core over loopback; it never opens the
+ * database, and drops the turn when Core is not running. Stdout stays empty,
+ * so the host does not treat the capture as another instruction.
  *
  * WorkBuddy's command lives in its plugin tree. Hermes and OpenClaw deliver
  * the turn through a single memory-provider slot; those are not written here,

memhub/packages/host-bridge/src/context-integration.test.ts

@@ -271,6 +271,87 @@ it("reads Core's SDK context directly and passes native fields unchanged", async
   );
 });
 
+it.each([
+  ["omitted", raw],
+  ["null", { ...raw, turn_id: null, turn_index: null, turn_count: null }],
+  [
+    "minimum populated",
+    {
+      ...raw,
+      turn_id: "t",
+      turn_index: 0,
+      turn_count: 1,
+    },
+  ],
+  [
+    "maximum populated",
+    {
+      ...raw,
+      turn_id: "t".repeat(96),
+      turn_index: Number.MAX_SAFE_INTEGER,
+      turn_count: Number.MAX_SAFE_INTEGER,
+    },
+  ],
+])("passes through %s optional raw turn metadata", async (_name, item) => {
+  const f = await fixture();
+  const response = receiptFor([item]);
+  f.respond(response);
+
+  const result = await f.post();
+
+  expect(result.status).toBe(200);
+  expect(result.data).toEqual(response);
+  expect(f.diagnostics).not.toContainEqual(
+    expect.objectContaining({ event: "context.response_invalid" }),
+  );
+});
+
+it.each([
+  ["empty turn_id", { turn_id: "" }],
+  ["overlong turn_id", { turn_id: "t".repeat(97) }],
+  ["non-string turn_id", { turn_id: 1 }],
+  ["negative turn_index", { turn_index: -1 }],
+  ["fractional turn_index", { turn_index: 0.5 }],
+  ["non-number turn_index", { turn_index: "0" }],
+  ["unsafe turn_index", { turn_index: 2 ** 53 }],
+  ["zero turn_count", { turn_count: 0 }],
+  ["negative turn_count", { turn_count: -1 }],
+  ["fractional turn_count", { turn_count: 1.5 }],
+  ["non-number turn_count", { turn_count: "1" }],
+  ["unsafe turn_count", { turn_count: 2 ** 53 }],
+  ["unknown field", { revision: 1 }],
+])("rejects raw context with %s", async (_name, fields) => {
+  const f = await fixture();
+  f.respond(receiptFor([{ ...raw, content: "private turn", ...fields }]));
+
+  const result = await f.post();
+
+  expect(result.status).toBe(502);
+  expect(result.data).toEqual({ error: "context_unavailable" });
+  expect(f.diagnostics).toContainEqual(
+    expect.objectContaining({
+      event: "context.response_invalid",
+      error_code: "invalid_context_response",
+      details: { reason: "response" },
+    }),
+  );
+  expect(JSON.stringify(f.diagnostics)).not.toContain("private turn");
+});
+
+it("rejects raw turn metadata on a memory context item", async () => {
+  const f = await fixture();
+  f.respond({
+    ...mixed,
+    items: [{ ...memory, turn_id: "t" }],
+    used_characters: [...memory.content].length,
+  });
+
+  const result = await f.post();
+
+  expect(result.status).toBe(502);
+  expect(result.data).toEqual({ error: "context_unavailable" });
+});
+
 it.each([
   [10, 200],
   [11, 502],

memhub/packages/host-bridge/src/context-protocol.ts

@@ -184,17 +184,30 @@ function validSdkItem(value: unknown): boolean {
   if (!record(value) || typeof value.truncated !== "boolean") return false;
   if (value.kind === "raw")
     return (
-      exact(value, [
-        "kind",
-        "raw_id",
-        "content",
-        "source",
-        "session_id",
-        "memory_at",
-        "score",
-        "truncated",
-      ]) &&
+      exact(
+        value,
+        [
+          "kind",
+          "raw_id",
+          "content",
+          "source",
+          "session_id",
+          "memory_at",
+          "score",
+          "truncated",
+        ],
+        ["turn_id", "turn_index", "turn_count"],
+      ) &&
       text(value.raw_id, 1, 512) &&
+      (value.turn_id === undefined ||
+        value.turn_id === null ||
+        text(value.turn_id, 1, 96)) &&
+      (value.turn_index === undefined ||
+        value.turn_index === null ||
+        integer(value.turn_index, 0, Number.MAX_SAFE_INTEGER)) &&
+      (value.turn_count === undefined ||
+        value.turn_count === null ||
+        integer(value.turn_count, 1, Number.MAX_SAFE_INTEGER)) &&
       text(value.content, 0, 20000) &&
       text(value.source, 1, 128) &&
       text(value.session_id, 1, 512) &&

memhub/packages/i18n/src/gui-i18n-catalogs.test.ts

@@ -229,6 +229,12 @@ describe("English catalog", () => {
   });
 
   it("uses CLDR English singular and plural forms", () => {
+    expect(translateCount("en", "sdk.raw.total", 1, { count: 1 })).toBe(
+      "1 original conversation",
+    );
+    expect(translateCount("en", "sdk.raw.total", 2, { count: 2 })).toBe(
+      "2 original conversations",
+    );
     expect(
       translateCount("en", "calls.headline.found", 1, {
         host: "Cursor",

memhub/packages/i18n/src/gui-i18n-current.ts

@@ -73,6 +73,8 @@ export const currentChineseMessages = {
   "sdk.raw.searchFailed": "原始对话搜索失败，请重试。",
   "sdk.raw.recent": "最近原始对话",
   "sdk.raw.empty": "还没有原始对话。连接来源后，对话会显示在这里。",
+  "sdk.raw.total": "{count} 条原始对话",
+  "sdk.raw.total.one": "{count} 条原始对话",
   "sdk.raw.found": "找到 {count} 条",
   "sdk.raw.found.one": "找到 {count} 条",
 
@@ -134,6 +136,7 @@ export const currentChineseMessages = {
   "selectedMemory.save": "保存修改",
   "selectedMemory.author.user": "你",
   "selectedMemory.author.agent": "助手",
+  "selectedMemory.author.tool": "工具",
   "selectedMemory.sourceUnavailable": "来源权限已变化或原文不可用。",
   "selectedMemory.related": "对应记忆",
   "selectedMemory.viewMemory": "查看记忆",
@@ -222,6 +225,8 @@ export const currentEnglishMessages: Record<
   "sdk.raw.recent": "Recent original conversations",
   "sdk.raw.empty":
     "No original conversations yet. Connect a source to see conversations here.",
+  "sdk.raw.total": "{count} original conversations",
+  "sdk.raw.total.one": "{count} original conversation",
   "sdk.raw.found": "{count} results",
   "sdk.raw.found.one": "{count} result",
 
@@ -289,6 +294,7 @@ export const currentEnglishMessages: Record<
   "selectedMemory.save": "Save changes",
   "selectedMemory.author.user": "You",
   "selectedMemory.author.agent": "Assistant",
+  "selectedMemory.author.tool": "Tool",
   "selectedMemory.sourceUnavailable":
     "Source permissions changed or the original text is unavailable.",
   "selectedMemory.related": "Related memory",
@@ -384,6 +390,8 @@ export const currentSpanishMessages: Record<
   "sdk.raw.recent": "Conversaciones originales recientes",
   "sdk.raw.empty":
     "Todavía no hay conversaciones originales. Conecta una fuente para verlas aquí.",
+  "sdk.raw.total": "{count} conversaciones originales",
+  "sdk.raw.total.one": "{count} conversación original",
   "sdk.raw.found": "{count} resultados",
   "sdk.raw.found.one": "{count} resultado",
 
@@ -452,6 +460,7 @@ export const currentSpanishMessages: Record<
   "selectedMemory.save": "Guardar cambios",
   "selectedMemory.author.user": "Tú",
   "selectedMemory.author.agent": "Asistente",
+  "selectedMemory.author.tool": "Herramienta",
   "selectedMemory.sourceUnavailable":
     "Los permisos del origen cambiaron o el texto no está disponible.",
   "selectedMemory.related": "Memoria correspondiente",

memhub/packages/i18n/src/gui-i18n-english.ts

@@ -877,7 +877,7 @@ const baseEnglishMessages = {
     "Keep syncing, processing and providing memories without opening the app.",
   导出日志: "Export logs",
   "把本机运行日志打包成一个文件，发给开发排查。":
-    "Package local diagnostic logs into a file to share with support.",
+    "Package all local logs. They may contain conversation text or local paths; share only with trusted developers.",
   "确定退出 One Memory 界面吗？": "Quit the MemHub window?",
   "后台服务会继续同步、整理和提供记忆。":
     "The background service will continue syncing, processing and providing memories.",

memhub/packages/i18n/src/gui-i18n-mode.ts

@@ -55,11 +55,11 @@ const modeChineseMessages = {
   "使用 pro 或 ultra 前需要先配置并启用生成模型。":
     "使用 pro 或 ultra 前需要先配置并启用生成模型。",
   "正在检查或切换向量模型，完成后才能切换记忆模式。":
-    "正在检查或切换向量模型，完成后才能切换记忆模式。",
+    "正在检查或切换向量模型，完成后才能选择记忆模式。",
   "当前安装缺少知识图谱组件，无法开启 ultra。":
-    "当前安装缺少知识图谱组件，无法开启 ultra。",
+    "当前安装缺少知识图谱组件，无法选择 ultra。",
   "模式切换未能确认，仍显示上次确认的模式。":
-    "模式切换未能确认，仍显示上次确认的模式。",
+    "模式选择未能确认，仍显示上次确认的模式。",
   "自动整合设置未能保存，请重试。": "自动整合设置未能保存，请重试。",
   "正在检查或切换向量模型，完成后才能整合记忆。":
     "正在检查或切换向量模型，完成后才能整合记忆。",
@@ -71,7 +71,7 @@ const modeChineseMessages = {
   "开发环境当前强制使用 ultra，保存的选择暂不会生效。":
     "开发环境当前强制使用 ultra，保存的选择暂不会生效。",
   "正在检查或切换向量模型，完成前不能切换模式或手动整合。":
-    "正在检查或切换向量模型，完成前不能切换模式或手动整合。",
+    "正在检查或切换向量模型，完成前不能选择模式或手动整合。",
   "正在把已有高级记忆加入知识图谱…": "正在把已有高级记忆加入知识图谱…",
   每天自动整合: "每天自动整合",
   "每天 {time} 自动运行 evolve，设备休眠错过后会补跑。":
@@ -83,10 +83,10 @@ const modeChineseMessages = {
   "上次整合：{time}": "上次整合：{time}",
   尚未整合: "尚未整合",
   立即整合: "立即整合",
-  "切换到 {mode}？": "切换到{mode}？",
-  "切换到 {mode}": "切换到{mode}",
+  "切换到 {mode}？": "选择{mode}？",
+  "切换到 {mode}": "选择{mode}",
   "原始对话在所有模式下都会保留。": "原始对话在所有模式下都会保留。",
-  切换模式: "切换模式",
+  切换模式: "确认选择",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "保存原始对话 · 不调用生成模型 · 搜索原始会话",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -98,18 +98,18 @@ const modeChineseMessages = {
   搜索范围: "搜索范围",
   已有数据: "已有数据",
   知识图谱: "知识图谱",
-  切换后: "切换后",
+  切换后: "选择后",
   "之后只保存原始对话，不再生成新记忆。":
     "之后只保存原始对话，不再生成新记忆。",
   "新对话会整理成记忆并写入知识图谱。": "新对话会整理成记忆并写入知识图谱。",
   "新对话会由模型整理成记忆。": "新对话会由模型整理成记忆。",
   "会调用当前生成模型；自动整合可能产生额外费用。切换本身不会立即整合。":
-    "会调用当前生成模型；自动整合可能产生额外费用。切换本身不会立即整合。",
+    "会调用当前生成模型；自动整合可能产生额外费用。选择模式本身不会立即整合。",
   "会调用当前生成模型，可能产生服务商费用。":
     "会调用当前生成模型，可能产生服务商费用。",
   "不调用生成模型，不再产生这部分费用。":
     "不调用生成模型，不再产生这部分费用。",
-  "切换后搜索原始对话。": "切换后搜索原始对话。",
+  "切换后搜索原始对话。": "选择后搜索原始对话。",
   "搜索沉淀记忆，并用知识图谱补充关联。":
     "搜索沉淀记忆，并用知识图谱补充关联。",
   "搜索沉淀后的记忆。": "搜索沉淀后的记忆。",
@@ -122,8 +122,8 @@ const modeChineseMessages = {
   "普通沉淀记忆仍可使用；更高层记忆和图谱数据继续保留，但不参与当前召回；每天自动整合会停止。":
     "普通沉淀记忆仍可使用；更高层记忆和图谱数据继续保留，但不参与当前召回；每天自动整合会停止。",
   "记忆维护正在进行，完成后才能切换模式。":
-    "记忆维护正在进行，完成后才能切换模式。",
-  "模式切换影响暂时无法读取，请重试。": "模式切换影响暂时无法读取，请重试。",
+    "记忆维护正在进行，完成后才能选择模式。",
+  "模式切换影响暂时无法读取，请重试。": "模式选择影响暂时无法读取，请重试。",
   "停止调用生成模型；每天自动整合也会停止。":
     "停止调用生成模型；每天自动整合也会停止。",
   "停止调用生成模型，不再产生这部分费用。":
@@ -281,11 +281,11 @@ export const modeEnglishMessages: ModeMessages = {
   "上次整合：{time}": "Last consolidated: {time}",
   尚未整合: "Not yet consolidated",
   立即整合: "Consolidate now",
-  "切换到 {mode}？": "Switch to {mode}?",
-  "切换到 {mode}": "Switch to {mode}",
+  "切换到 {mode}？": "Choose {mode}?",
+  "切换到 {mode}": "Choose {mode}",
   "原始对话在所有模式下都会保留。":
     "Original conversations are kept in every mode.",
-  切换模式: "Switch mode",
+  切换模式: "Confirm choice",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "Save original conversations · No generation model calls · Search original conversations",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -485,11 +485,11 @@ export const modeSpanishMessages: ModeMessages = {
   "上次整合：{time}": "Última consolidación: {time}",
   尚未整合: "Aún sin consolidar",
   立即整合: "Consolidar ahora",
-  "切换到 {mode}？": "¿Cambiar a {mode}?",
-  "切换到 {mode}": "Cambiar a {mode}",
+  "切换到 {mode}？": "¿Elegir {mode}?",
+  "切换到 {mode}": "Elegir {mode}",
   "原始对话在所有模式下都会保留。":
     "Las conversaciones originales se conservan en todos los modos.",
-  切换模式: "Cambiar modo",
+  切换模式: "Confirmar selección",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "Guarda conversaciones originales · Sin llamadas al modelo generativo · Busca conversaciones originales",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -682,10 +682,10 @@ export const modeTraditionalChineseMessages: ModeMessages = {
   "上次整合：{time}": "上次整合：{time}",
   尚未整合: "尚未整合",
   立即整合: "立即整合",
-  "切换到 {mode}？": "切換到{mode}？",
-  "切换到 {mode}": "切換到{mode}",
+  "切换到 {mode}？": "選擇{mode}？",
+  "切换到 {mode}": "選擇{mode}",
   "原始对话在所有模式下都会保留。": "原始對話會在所有模式下保留。",
-  切换模式: "切換模式",
+  切换模式: "確認選擇",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "儲存原始對話 · 不呼叫生成模型 · 搜尋原始對話",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -833,10 +833,10 @@ export const modeJapaneseMessages: ModeMessages = {
   "上次整合：{time}": "前回の統合：{time}",
   尚未整合: "まだ統合されていません",
   立即整合: "今すぐ統合",
-  "切换到 {mode}？": "{mode} に切り替えますか？",
-  "切换到 {mode}": "{mode} に切り替える",
+  "切换到 {mode}？": "{mode} を選択しますか？",
+  "切换到 {mode}": "{mode} を選択",
   "原始对话在所有模式下都会保留。": "元の会話はどのモードでも保持されます。",
-  切换模式: "モードを切り替える",
+  切换模式: "選択を確定",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "元の会話を保存 · 生成モデルを呼び出さない · 元の会話を検索",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -1033,11 +1033,11 @@ export const modeGermanMessages: ModeMessages = {
   "上次整合：{time}": "Zuletzt konsolidiert: {time}",
   尚未整合: "Noch nicht konsolidiert",
   立即整合: "Jetzt konsolidieren",
-  "切换到 {mode}？": "Zu {mode} wechseln?",
-  "切换到 {mode}": "Zu {mode} wechseln",
+  "切换到 {mode}？": "{mode} auswählen?",
+  "切换到 {mode}": "{mode} auswählen",
   "原始对话在所有模式下都会保留。":
     "Originalunterhaltungen bleiben in jedem Modus erhalten.",
-  切换模式: "Modus wechseln",
+  切换模式: "Auswahl bestätigen",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "Originalunterhaltungen speichern · Keine Aufrufe des generativen Modells · Originalunterhaltungen durchsuchen",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -1237,11 +1237,11 @@ export const modePortugueseMessages: ModeMessages = {
   "上次整合：{time}": "Última consolidação: {time}",
   尚未整合: "Ainda não consolidado",
   立即整合: "Consolidar agora",
-  "切换到 {mode}？": "Mudar para {mode}?",
-  "切换到 {mode}": "Mudar para {mode}",
+  "切换到 {mode}？": "Escolher {mode}?",
+  "切换到 {mode}": "Escolher {mode}",
   "原始对话在所有模式下都会保留。":
     "As conversas originais são mantidas em todos os modos.",
-  切换模式: "Mudar de modo",
+  切换模式: "Confirmar escolha",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "Guardar conversas originais · Sem chamadas ao modelo generativo · Pesquisar conversas originais",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -1443,11 +1443,11 @@ export const modeFrenchMessages: ModeMessages = {
   "上次整合：{time}": "Dernière consolidation : {time}",
   尚未整合: "Pas encore consolidé",
   立即整合: "Consolider maintenant",
-  "切换到 {mode}？": "Passer à {mode} ?",
-  "切换到 {mode}": "Passer à {mode}",
+  "切换到 {mode}？": "Choisir {mode} ?",
+  "切换到 {mode}": "Choisir {mode}",
   "原始对话在所有模式下都会保留。":
     "Les conversations originales sont conservées dans tous les modes.",
-  切换模式: "Changer de mode",
+  切换模式: "Confirmer le choix",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "Enregistrer les conversations originales · Aucun appel au modèle génératif · Rechercher les conversations originales",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -1645,10 +1645,10 @@ export const modeKoreanMessages: ModeMessages = {
   "上次整合：{time}": "마지막 통합: {time}",
   尚未整合: "아직 통합되지 않음",
   立即整合: "지금 통합",
-  "切换到 {mode}？": "{mode}(으)로 전환할까요?",
-  "切换到 {mode}": "{mode}(으)로 전환",
+  "切换到 {mode}？": "{mode}을(를) 선택할까요?",
+  "切换到 {mode}": "{mode} 선택",
   "原始对话在所有模式下都会保留。": "원본 대화는 모든 모드에서 유지됩니다.",
-  切换模式: "모드 전환",
+  切换模式: "선택 확인",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "원본 대화 저장 · 생성 모델 호출 없음 · 원본 대화 검색",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -1844,11 +1844,11 @@ export const modeRussianMessages: ModeMessages = {
   "上次整合：{time}": "Последнее объединение: {time}",
   尚未整合: "Ещё не объединялись",
   立即整合: "Объединить сейчас",
-  "切换到 {mode}？": "Переключиться на {mode}?",
-  "切换到 {mode}": "Переключиться на {mode}",
+  "切换到 {mode}？": "Выбрать {mode}?",
+  "切换到 {mode}": "Выбрать {mode}",
   "原始对话在所有模式下都会保留。":
     "Исходные диалоги сохраняются во всех режимах.",
-  切换模式: "Переключить режим",
+  切换模式: "Подтвердить выбор",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "Сохранять исходные диалоги · Не вызывать генеративную модель · Искать в исходных диалогах",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":
@@ -2048,10 +2048,10 @@ export const modeIndonesianMessages: ModeMessages = {
   "上次整合：{time}": "Terakhir dikonsolidasikan: {time}",
   尚未整合: "Belum dikonsolidasikan",
   立即整合: "Konsolidasikan sekarang",
-  "切换到 {mode}？": "Beralih ke {mode}?",
-  "切换到 {mode}": "Beralih ke {mode}",
+  "切换到 {mode}？": "Pilih {mode}?",
+  "切换到 {mode}": "Pilih {mode}",
   "原始对话在所有模式下都会保留。": "Percakapan asli disimpan di semua mode.",
-  切换模式: "Beralih mode",
+  切换模式: "Konfirmasi pilihan",
   "保存原始对话 · 不调用生成模型 · 搜索原始会话":
     "Simpan percakapan asli · Tanpa panggilan model generatif · Cari percakapan asli",
   "沉淀高级记忆 · 调用生成模型 · 搜索沉淀记忆":

memhub/packages/i18n/src/gui-i18n-settings.ts

@@ -251,7 +251,7 @@ export const settingsSpanishMessages = {
     "Sincroniza, organiza y ofrece memorias sin abrir la interfaz.",
   导出日志: "Exportar registros",
   "把本机运行日志打包成一个文件，发给开发排查。":
-    "Empaqueta los registros locales en un archivo para su diagnóstico.",
+    "Empaqueta todos los registros locales. Pueden contener conversaciones o rutas privadas; compártelos solo con personal de desarrollo de confianza.",
   "确定退出 One Memory 界面吗？": "¿Cerrar la interfaz de MemHub?",
   "后台服务会继续同步、整理和提供记忆。":
     "El servicio en segundo plano seguirá sincronizando, organizando y ofreciendo memorias.",
@@ -362,6 +362,8 @@ export const settingsSpanishMessages = {
 const chineseOverrides: Partial<
   Record<keyof typeof settingsSpanishMessages, string>
 > = {
+  "把本机运行日志打包成一个文件，发给开发排查。":
+    "打包完整本机日志，可能包含会话正文和本机路径；只发送给可信的开发人员。",
   "确定退出 One Memory 界面吗？": "确定退出 MemHub 界面吗？",
   appSettingsTitle: "{name} 应用设置",
   appMemoryScope: "让 {name} 查询已授权范围内的记忆。",

memhub/packages/i18n/src/gui-i18n.test.ts

@@ -239,7 +239,7 @@ describe("GUI messages", () => {
         "上次整合：11/3/2026, 4:00:00 PM",
         "Last consolidated: 11/3/2026, 4:00:00 PM",
       ],
-      ["切换到 ultra？", "Switch to ultra?"],
+      ["切换到 ultra？", "Choose ultra?"],
     ] as const;
     for (const [source, expected] of cases) {
       expect(isMessageKey(source)).toBe(true);

memhub/packages/i18n/src/locales/gui-i18n-de.ts

@@ -86,6 +86,8 @@ export const germanMessages: Record<MessageKey, string> = {
   "sdk.raw.recent": "Letzte Originalunterhaltungen",
   "sdk.raw.empty":
     "Noch keine Originalunterhaltungen. Verbinde eine Quelle, damit sie hier erscheinen.",
+  "sdk.raw.total": "{count} Originalunterhaltungen",
+  "sdk.raw.total.one": "{count} Originalunterhaltung",
   "memory:当前使用基础记忆。新对话会保存为原始记录，不会生成高级记忆；以前生成的高级记忆仍会保留，但当前不会显示或参与记忆召回。":
     "Der Basisspeicher ist aktiv. Neue Unterhaltungen werden als Originale gespeichert und erzeugen keine erweiterten Erinnerungen. Vorhandene erweiterte Erinnerungen bleiben gespeichert, werden aber nicht angezeigt oder abgerufen.",
   "memory:当前使用智能记忆。新对话会由模型整理为高级记忆。":
@@ -158,6 +160,7 @@ export const germanMessages: Record<MessageKey, string> = {
   "selectedMemory.save": "Speichern",
   "selectedMemory.author.user": "Sie",
   "selectedMemory.author.agent": "Assistent",
+  "selectedMemory.author.tool": "Tool",
   "selectedMemory.sourceUnavailable":
     "Quellberechtigungen haben sich geändert oder der Originaltext ist nicht verfügbar.",
   "selectedMemory.related": "Zugehörige Erinnerung",
@@ -1065,7 +1068,7 @@ export const germanMessages: Record<MessageKey, string> = {
     "Erinnerungen weiter synchronisieren, verarbeiten und bereitstellen, ohne die App zu öffnen.",
   导出日志: "Protokolle exportieren",
   "把本机运行日志打包成一个文件，发给开发排查。":
-    "Packen Sie lokale Diagnoseprotokolle in eine Datei, um sie an den Support zu senden.",
+    "Packt alle lokalen Protokolle. Sie können Gesprächsinhalte oder lokale Pfade enthalten; nur mit vertrauenswürdigen Entwicklern teilen.",
   "确定退出 One Memory 界面吗？": "MemHub-Fenster beenden?",
   "后台服务会继续同步、整理和提供记忆。":
     "Der Hintergrunddienst synchronisiert, verarbeitet und liefert Erinnerungen weiter.",

memhub/packages/i18n/src/locales/gui-i18n-fr.ts

@@ -87,6 +87,8 @@ export const frenchMessages: Record<MessageKey, string> = {
   "sdk.raw.recent": "Conversations originales récentes",
   "sdk.raw.empty":
     "Aucune conversation originale pour le moment. Connectez une source pour les afficher ici.",
+  "sdk.raw.total": "{count} conversations originales",
+  "sdk.raw.total.one": "{count} conversation originale",
   "memory:当前使用基础记忆。新对话会保存为原始记录，不会生成高级记忆；以前生成的高级记忆仍会保留，但当前不会显示或参与记忆召回。":
     "La mémoire de base est active. Les nouvelles conversations sont conservées telles quelles et ne créent pas de mémoires avancées. Les mémoires avancées existantes restent enregistrées, mais ne sont ni affichées ni rappelées.",
   "memory:当前使用智能记忆。新对话会由模型整理为高级记忆。":
@@ -162,6 +164,7 @@ export const frenchMessages: Record<MessageKey, string> = {
   "selectedMemory.save": "Enregistrer",
   "selectedMemory.author.user": "Vous",
   "selectedMemory.author.agent": "Assistant",
+  "selectedMemory.author.tool": "Outil",
   "selectedMemory.sourceUnavailable":
     "Les autorisations de la source ont changé ou le texte original est indisponible.",
   "selectedMemory.related": "Mémoire associée",
@@ -1078,7 +1081,7 @@ export const frenchMessages: Record<MessageKey, string> = {
     "Continuez à synchroniser, traiter et fournir les mémoires sans ouvrir l’application.",
   导出日志: "Exporter les journaux",
   "把本机运行日志打包成一个文件，发给开发排查。":
-    "Regroupez les journaux de diagnostic locaux dans un fichier à transmettre à l’assistance.",
+    "Regroupe tous les journaux locaux. Ils peuvent contenir des conversations ou des chemins locaux ; partagez-les uniquement avec des développeurs de confiance.",
   "确定退出 One Memory 界面吗？": "Quitter la fenêtre MemHub ?",
   "后台服务会继续同步、整理和提供记忆。":
     "Le service en arrière-plan continuera de synchroniser, traiter et fournir les mémoires.",

memhub/packages/i18n/src/locales/gui-i18n-id.ts

@@ -81,6 +81,8 @@ export const indonesianMessages: Record<MessageKey, string> = {
   "sdk.raw.recent": "Percakapan asli terbaru",
   "sdk.raw.empty":
     "Belum ada percakapan asli. Hubungkan sumber agar percakapan tampil di sini.",
+  "sdk.raw.total": "{count} percakapan asli",
+  "sdk.raw.total.one": "{count} percakapan asli",
   "memory:当前使用基础记忆。新对话会保存为原始记录，不会生成高级记忆；以前生成的高级记忆仍会保留，但当前不会显示或参与记忆召回。":
     "Memori dasar aktif. Percakapan baru disimpan sebagai catatan asli dan tidak membuat memori lanjutan. Memori lanjutan yang ada tetap tersimpan, tetapi tidak ditampilkan atau digunakan untuk recall.",
   "memory:当前使用智能记忆。新对话会由模型整理为高级记忆。":
@@ -151,6 +153,7 @@ export const indonesianMessages: Record<MessageKey, string> = {
   "selectedMemory.save": "Simpan perubahan",
   "selectedMemory.author.user": "Anda",
   "selectedMemory.author.agent": "Asisten",
+  "selectedMemory.author.tool": "Alat",
   "selectedMemory.sourceUnavailable":
     "Izin sumber berubah atau teks asli tidak tersedia.",
   "selectedMemory.related": "Memori terkait",
@@ -1048,7 +1051,7 @@ export const indonesianMessages: Record<MessageKey, string> = {
     "Terus sinkronkan, proses, dan sediakan memori tanpa membuka aplikasi.",
   导出日志: "Ekspor log",
   "把本机运行日志打包成一个文件，发给开发排查。":
-    "Kemas log diagnostik lokal menjadi satu file untuk dibagikan ke tim dukungan.",
+    "Kemas semua log lokal. Log dapat memuat isi percakapan atau jalur lokal; bagikan hanya kepada pengembang tepercaya.",
   "确定退出 One Memory 界面吗？": "Tutup jendela MemHub?",
   "后台服务会继续同步、整理和提供记忆。":
     "Layanan latar belakang akan terus menyinkronkan, memproses, dan menyediakan memori.",

memhub/packages/i18n/src/locales/gui-i18n-ja.ts

@@ -83,6 +83,8 @@ export const japaneseMessages: Record<MessageKey, string> = {
   "sdk.raw.recent": "最近の元の会話",
   "sdk.raw.empty":
     "元の会話はまだありません。ソースを接続すると、ここに表示されます。",
+  "sdk.raw.total": "元の会話 {count} 件",
+  "sdk.raw.total.one": "元の会話 {count} 件",
   "memory:当前使用基础记忆。新对话会保存为原始记录，不会生成高级记忆；以前生成的高级记忆仍会保留，但当前不会显示或参与记忆召回。":
     "基本メモリを使用中です。新しい会話は原文として保存され、高度なメモリは生成されません。既存の高度なメモリは保持されますが、現在は表示も呼び出しもされません。",
   "memory:当前使用智能记忆。新对话会由模型整理为高级记忆。":
@@ -152,6 +154,7 @@ export const japaneseMessages: Record<MessageKey, string> = {
   "selectedMemory.save": "変更を保存",
   "selectedMemory.author.user": "あなた",
   "selectedMemory.author.agent": "アシスタント",
+  "selectedMemory.author.tool": "ツール",
   "selectedMemory.sourceUnavailable":
     "ソースの権限が変更されたか、原文を利用できません。",
   "selectedMemory.related": "関連する記憶",
@@ -1045,7 +1048,7 @@ export const japaneseMessages: Record<MessageKey, string> = {
     "アプリを開かなくても、記憶の同期、処理、提供を続けます。",
   导出日志: "ログを書き出す",
   "把本机运行日志打包成一个文件，发给开发排查。":
-    "ローカルの診断ログを 1 つのファイルにまとめ、サポートに共有できます。",
+    "ローカルログをすべてまとめます。会話本文やローカルパスが含まれる場合があるため、信頼できる開発者にのみ共有してください。",
   "确定退出 One Memory 界面吗？": "MemHub のウインドウを終了しますか？",
   "后台服务会继续同步、整理和提供记忆。":
     "バックグラウンドサービスは記憶の同期、処理、提供を続けます。",

memhub/packages/i18n/src/locales/gui-i18n-ko.ts

@@ -80,6 +80,8 @@ export const koreanMessages: Record<MessageKey, string> = {
   "sdk.raw.recent": "최근 원본 대화",
   "sdk.raw.empty":
     "아직 원본 대화가 없습니다. 소스를 연결하면 여기에 표시됩니다.",
+  "sdk.raw.total": "원본 대화 {count}개",
+  "sdk.raw.total.one": "원본 대화 {count}개",
   "memory:当前使用基础记忆。新对话会保存为原始记录，不会生成高级记忆；以前生成的高级记忆仍会保留，但当前不会显示或参与记忆召回。":
     "기본 메모리를 사용 중입니다. 새 대화는 원본 기록으로 저장되며 고급 메모리를 만들지 않습니다. 기존 고급 메모리는 보존되지만 현재 표시되거나 회상에 사용되지 않습니다.",
   "memory:当前使用智能记忆。新对话会由模型整理为高级记忆。":
@@ -149,6 +151,7 @@ export const koreanMessages: Record<MessageKey, string> = {
   "selectedMemory.save": "변경 사항 저장",
   "selectedMemory.author.user": "나",
   "selectedMemory.author.agent": "어시스턴트",
+  "selectedMemory.author.tool": "도구",
   "selectedMemory.sourceUnavailable":
     "출처 권한이 변경되었거나 원문을 사용할 수 없습니다.",
   "selectedMemory.related": "관련 기억",
@@ -1021,7 +1024,7 @@ export const koreanMessages: Record<MessageKey, string> = {
     "앱을 열지 않아도 기억을 계속 동기화, 정리하고 제공합니다.",
   导出日志: "로그 내보내기",
   "把本机运行日志打包成一个文件，发给开发排查。":
-    "로컬 진단 로그를 파일 하나로 묶어 지원팀에 보냅니다.",
+    "모든 로컬 로그를 묶습니다. 대화 내용이나 로컬 경로가 포함될 수 있으므로 신뢰할 수 있는 개발자에게만 공유하세요.",
   "确定退出 One Memory 界面吗？": "MemHub 창을 종료하시겠습니까?",
   "后台服务会继续同步、整理和提供记忆。":
     "백그라운드 서비스는 계속 기억을 동기화, 정리하고 제공합니다.",