@modusensus/dsh-mneme 0.7.31 → 0.8.0

package/lib/client.js

@@ -105,6 +105,31 @@ window.__ModuleLoader__.load({
         h("span", { className: "mneme-heatpct" }, `${pct}%`));
     };
 
+    /**
+     * v0.8.0 A4（issue #17）：scope 标注徽章——条目的归属来源一行摘要。
+     *
+     * 仅在条目带任一 scope 标注（agent_scope / workspace_scope / sensitivity）
+     * 时渲染；字段缺省返回 null（未标注条目视觉零变化，前端不感知开关状态，
+     * 与 HeatBadge 的「数据缺省即不渲染」同一模式）。tooltip 展示完整归属，
+     * 标签复用详情抽屉的 i18n 键（云端复验观察点：tooltip 曾硬编码英文）。
+     *
+     * @param {{m: object, t: (key: string) => string}} props
+     * @param {object} props.m 记忆条目（/list、/search 透出的 toApiList 形状，
+     *   scope 四字段条件存在）
+     * @param {(key: string) => string} props.t i18n 取词函数（调用点闭包提供）
+     * @returns {object|null} 徽章 vnode；无任何标注时为 null
+     */
+    const ScopeBadge = ({ m, t }) => {
+      if (!m || (!m.agent_scope && !m.workspace_scope && !m.sensitivity)) return null;
+      const tip = [
+        m.agent_scope ? `${t("memory.explorer.detail.agentScope")}: ${m.agent_scope}` : null,
+        m.workspace_scope ? `${t("memory.explorer.detail.workspaceScope")}: ${m.workspace_scope}` : null,
+        m.sensitivity ? `${t("memory.explorer.detail.sensitivity")}: ${m.sensitivity}` : null
+      ].filter(Boolean).join(" · ");
+      return h("span", { className: "mneme-badge mneme-badge--scope", title: tip },
+        t("memory.explorer.scopeBadge"));
+    };
+
     // Unified API fetcher: attaches the optional apiToken (set in the settings
     // view, persisted in localStorage) as a Bearer header. When no token has
     // been configured the header is omitted and the API stays open (default).
@@ -270,6 +295,7 @@ window.__ModuleLoader__.load({
         "memory.features.group.core": "核心",
         "memory.features.group.enhance": "记忆增强",
         "memory.features.group.dream": "巩固与睡眠",
+        "memory.features.group.scope": "作用域隔离",
         "memory.features.group.advanced": "高级",
         "memory.features.advancedToggle": "高级（注入策略 · 反思 · 实验项）",
         "memory.features.restartHint": "重启 DSH 后生效",
@@ -322,6 +348,10 @@ window.__ModuleLoader__.load({
         "memory.features.bm25SearchEnabled.hint": "传统关键词打分检索，与向量召回互补",
         "memory.features.conflictFreezeEnabled": "冲突冻结",
         "memory.features.conflictFreezeEnabled.hint": "巩固发现互相矛盾的记忆时先冻结待确认",
+        "memory.features.scopeEnabled": "作用域标注",
+        "memory.features.scopeEnabled.hint": "按会话身份（agent/工作区）给新记忆打归属标注；重启 DSH 后生效",
+        "memory.features.strictScope": "严格隔离",
+        "memory.features.strictScope.hint": "检索与注入硬过滤：带他者作用域的记忆完全不可见（关闭时仅降权保留可见）；重启 DSH 后生效",
         "memory.features.trustEpistemicWeighting": "可信度加权",
         "memory.features.trustEpistemicWeighting.hint": "按来源可信度调整召回排序（实验性）",
         "memory.features.reflectionFailureTracking": "反思失败追踪",
@@ -374,6 +404,11 @@ window.__ModuleLoader__.load({
         "memory.explorer.exportFailed": "导出失败",
         "memory.explorer.conflictBadge": "冲突",
         "memory.explorer.archivedBadge": "已归档",
+        "memory.explorer.scopeBadge": "作用域",
+        "memory.explorer.detail.agentScope": "Agent 作用域",
+        "memory.explorer.detail.workspaceScope": "工作区作用域",
+        "memory.explorer.detail.sensitivity": "敏感度",
+        "memory.explorer.detail.occurred": "发生时间",
         "memory.explorer.detail.edit": "编辑",
         "memory.explorer.detail.save": "保存",
         "memory.explorer.detail.cancel": "取消",
@@ -394,6 +429,15 @@ window.__ModuleLoader__.load({
         "memory.status.dreamNever": "尚未运行",
         "memory.status.conflicts": "待确认冲突",
         "memory.status.conflictsHint": "冻结的矛盾记忆，等待人工确认",
+        "memory.status.conflictQueue.reason": "原因",
+        "memory.status.conflictQueue.sideA": "A 方",
+        "memory.status.conflictQueue.sideB": "B 方",
+        "memory.status.conflictQueue.keepA": "保留 A",
+        "memory.status.conflictQueue.keepB": "保留 B",
+        "memory.status.conflictQueue.markReviewed": "仅标记已处理",
+        "memory.status.conflictQueue.applyHint": "确认后：保留方正文追加已否决注记，另一方归档。",
+        "memory.status.conflictQueue.missing": "（该记忆已不存在）",
+        "memory.status.conflictQueue.refresh": "刷新队列",
         "memory.status.workbench": "工作动态",
         "memory.status.dreamConsolidate": "记忆巩固",
         "memory.status.summarize": "总结提炼",
@@ -427,7 +471,24 @@ window.__ModuleLoader__.load({
         "memory.status.vectorOff": "未启用",
         "memory.status.vectorInit": "初始化中",
         "memory.status.vectorInitHint": "embedder 不可达，正在重试",
+        "memory.status.vectorRuntimeMissing": "缺少本地推理运行时",
+        "memory.status.vectorRuntimeHint": "本地推理运行时未就绪（{status}）",
+        "memory.status.vectorRuntimeCost": "本地向量化要额外一份本地推理运行时（transformers + onnxruntime 闭包，解包后数百 MB）。下面的按钮会先尝试收编本机已有的那份（同盘则硬链接，不占额外空间），没有再按固定清单从 npm 取回（逐个校验 sha512）。也可以直接让 agent 处理，或在终端里自己跑：node scripts/mneme-runtime.mjs status / adopt [--from <node_modules>] / verify（详见 docs/LOCAL_MODEL.md §2.5）。",
+        "memory.runtime.title": "本地推理运行时",
+        "memory.runtime.available": "已就绪",
+        "memory.runtime.missing": "未就绪 —— 只有用本地嵌入（embedProvider: local）时才需要它",
+        "memory.runtime.restart": "本地嵌入要重启 DSH 才会生效",
+        "memory.status.vectorRuntimeReady": "运行时已就绪",
+        "memory.status.vectorRuntimeReadyHint": "本地嵌入尚未初始化（进程里的 embedder 在运行时缺失时已经失败过一次）：若一直停在这里，重启 DSH 即可。",
+        "memory.status.vectorRuntimeFetch": "取回本地运行时",
+        "memory.status.vectorRuntimeFetchBusy": "正在取回…（先试收编，必要时下载，数千个文件，请稍候）",
+        "memory.status.vectorRuntimeFetchAdopted": "已收编本机已有的运行时：{n} 个包 / {m} 个文件（{mode}）。**请重启 DSH 使本地嵌入生效。**",
+        "memory.status.vectorRuntimeFetchDownloaded": "下载完成：{n} 个包 / {m} 个文件。**请重启 DSH 使本地嵌入生效**（取回不会让当前进程里的 embedder 复活）。",
+        "memory.status.vectorRuntimeFetchFailed": "取回失败：{reason}",
         "memory.status.vectorIndexed": "已索引 {n} / {m} 条",
+      "memory.status.vectorUnconfigured": "未配置",
+      "memory.status.vectorUnconfiguredHint": "未填 embedding 端点/模型或未启用，语义召回不可用",
+      "memory.status.vectorDegradedHint": "已索引 0 / {m} 条，语义召回实际不可用",
         "memory.status.llm": "LLM 消耗",
         "memory.status.llmCalls": "近 7 天 · {n} 次调用",
         "memory.status.error": "加载失败"
@@ -575,6 +636,7 @@ window.__ModuleLoader__.load({
         "memory.features.group.core": "Core",
         "memory.features.group.enhance": "Enhancement",
         "memory.features.group.dream": "Consolidation",
+        "memory.features.group.scope": "Scope isolation",
         "memory.features.group.advanced": "Advanced",
         "memory.features.advancedToggle": "Advanced (injection · reflection · experimental)",
         "memory.features.restartHint": "Takes effect after restarting DSH",
@@ -627,6 +689,10 @@ window.__ModuleLoader__.load({
         "memory.features.bm25SearchEnabled.hint": "Classic keyword scoring, complementary to vector recall",
         "memory.features.conflictFreezeEnabled": "Conflict freezing",
         "memory.features.conflictFreezeEnabled.hint": "Freeze contradictory memories for confirmation during consolidation",
+        "memory.features.scopeEnabled": "Scope tagging",
+        "memory.features.scopeEnabled.hint": "Stamp new memories with the writing session's identity (agent/workspace); takes effect after restarting DSH",
+        "memory.features.strictScope": "Strict isolation",
+        "memory.features.strictScope.hint": "Hard-filter search and injection: memories scoped to other agents/workspaces become invisible (off = demoted but visible); takes effect after restarting DSH",
         "memory.features.trustEpistemicWeighting": "Credibility weighting",
         "memory.features.trustEpistemicWeighting.hint": "Adjust recall ranking by source credibility (experimental)",
         "memory.features.reflectionFailureTracking": "Reflection failure tracking",
@@ -679,6 +745,11 @@ window.__ModuleLoader__.load({
         "memory.explorer.exportFailed": "Export failed",
         "memory.explorer.conflictBadge": "Conflict",
         "memory.explorer.archivedBadge": "Archived",
+        "memory.explorer.scopeBadge": "Scoped",
+        "memory.explorer.detail.agentScope": "Agent scope",
+        "memory.explorer.detail.workspaceScope": "Workspace scope",
+        "memory.explorer.detail.sensitivity": "Sensitivity",
+        "memory.explorer.detail.occurred": "Occurred",
         "memory.explorer.detail.edit": "Edit",
         "memory.explorer.detail.save": "Save",
         "memory.explorer.detail.cancel": "Cancel",
@@ -699,6 +770,15 @@ window.__ModuleLoader__.load({
         "memory.status.dreamNever": "Not yet run",
         "memory.status.conflicts": "Pending conflicts",
         "memory.status.conflictsHint": "Frozen contradictory memories awaiting confirmation",
+        "memory.status.conflictQueue.reason": "Reason",
+        "memory.status.conflictQueue.sideA": "Side A",
+        "memory.status.conflictQueue.sideB": "Side B",
+        "memory.status.conflictQueue.keepA": "Keep A",
+        "memory.status.conflictQueue.keepB": "Keep B",
+        "memory.status.conflictQueue.markReviewed": "Mark reviewed only",
+        "memory.status.conflictQueue.applyHint": "On confirm: a veto note is appended to the kept side and the other side is archived.",
+        "memory.status.conflictQueue.missing": "(memory no longer exists)",
+        "memory.status.conflictQueue.refresh": "Refresh queue",
         "memory.status.workbench": "Activity",
         "memory.status.dreamConsolidate": "Consolidation",
         "memory.status.summarize": "Summarization",
@@ -732,7 +812,24 @@ window.__ModuleLoader__.load({
         "memory.status.vectorOff": "Disabled",
         "memory.status.vectorInit": "Initializing",
         "memory.status.vectorInitHint": "embedder unreachable, retrying",
+        "memory.status.vectorRuntimeMissing": "Local inference runtime missing",
+        "memory.status.vectorRuntimeHint": "Local inference runtime not ready ({status})",
+        "memory.status.vectorRuntimeCost": "Local vectorization needs an extra local inference runtime (the transformers + onnxruntime closure, hundreds of MB unpacked). The button below first tries to adopt an existing copy on this machine (hardlinked when on the same volume, so no extra disk), and otherwise fetches it from npm against a pinned manifest (every tarball checked against its sha512). You can also just ask the agent, or run it yourself: node scripts/mneme-runtime.mjs status / adopt [--from <node_modules>] / verify (see docs/LOCAL_MODEL.md §2.5).",
+        "memory.runtime.title": "Local inference runtime",
+        "memory.runtime.available": "ready",
+        "memory.runtime.missing": "not ready — only needed when you use local embedding (embedProvider: local)",
+        "memory.runtime.restart": "Local embedding takes effect after restarting DSH",
+        "memory.status.vectorRuntimeReady": "Runtime ready",
+        "memory.status.vectorRuntimeReadyHint": "Local embedder is not initialized yet (the in-process embedder already failed while the runtime was missing): restart DSH if this persists.",
+        "memory.status.vectorRuntimeFetch": "Fetch local runtime",
+        "memory.status.vectorRuntimeFetchBusy": "Fetching… (tries adopt first, may download — thousands of files)",
+        "memory.status.vectorRuntimeFetchAdopted": "Adopted the runtime already on this machine: {n} packages / {m} files ({mode}). **Restart DSH to activate local embedding.**",
+        "memory.status.vectorRuntimeFetchDownloaded": "Download complete: {n} packages / {m} files. **Restart DSH to activate local embedding** (fetching does not revive the embedder already running in this process).",
+        "memory.status.vectorRuntimeFetchFailed": "Fetch failed: {reason}",
         "memory.status.vectorIndexed": "Indexed {n} / {m} items",
+      "memory.status.vectorUnconfigured": "Not configured",
+      "memory.status.vectorUnconfiguredHint": "No embedding endpoint/model configured — semantic recall is off",
+      "memory.status.vectorDegradedHint": "Indexed 0 / {m} items — semantic recall is effectively unavailable",
         "memory.status.llm": "LLM Usage",
         "memory.status.llmCalls": "Last 7 days · {n} calls",
         "memory.status.error": "Failed to load"
@@ -957,10 +1054,9 @@ window.__ModuleLoader__.load({
       ".mneme-heat--warm{color:var(--dsw-alias-label-secondary)}",
       ".mneme-heat--cold{color:var(--dsw-alias-label-tertiary)}",
       ".mneme-heat--cold .mneme-heatpct{display:none}",
-      // width:100% 与「新会话」同宽（同一弹性父容器）；文案对齐交给复制来的
-      // 原生类，不再用 flex:1/text-align:left 覆盖成左对齐。
-      ".mneme-topentry{display:contents}",
-      ".mneme-topentry-native{width:100%;background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-primary)}",
+      // 纵向 flex 容器按原生按钮的宽度与外边距分配空间，保留展开和收起态的对齐。
+      ".mneme-topentry{display:flex;flex-direction:column}",
+      ".mneme-topentry-native{background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-primary)}",
       ".mneme-topentry-native:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
       ".mneme-topentry-native .mneme-topentry-label{white-space:nowrap}",
       // --- 功能开关：一行一开关，Claude 式安静排版 ---
@@ -987,6 +1083,8 @@ window.__ModuleLoader__.load({
       ".mneme-featsub{margin:2px 0 8px;padding:10px 12px;border:1px solid var(--dsw-alias-border-l1);border-radius:10px;display:flex;flex-direction:column;gap:6px}",
       ".mneme-featsub .mneme-featnum{padding:6px 0;border-bottom:none}",
       ".mneme-featsubhint{font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary)}",
+      // 运行时那一块的说明文字：比常规 hint 再小一档，它是背景信息而不是要读的正文。
+      ".mneme-runtimehint{font-size:11px;line-height:16px;color:var(--dsw-alias-label-tertiary)}",
       // --- 交互式记忆库：工具栏 / 卡片网格 / 详情抽屉 / 更多菜单 ---
       // sheet 边距放宽：与窗口边缘保持呼吸距离，居中不顶满。
       // 视图切换（卡片/时间线）分段控件挂在子页栏右侧。
@@ -1008,6 +1106,20 @@ window.__ModuleLoader__.load({
       ".mneme-badge{flex:none;display:inline-flex;align-items:center;gap:4px;height:18px;padding:0 7px;border-radius:6px;font-size:11px;line-height:14px}",
       ".mneme-badge--conflict{color:var(--dsw-alias-state-error,#c33);background:color-mix(in srgb,var(--dsw-alias-state-error,#c33) 10%,transparent);border:1px solid color-mix(in srgb,var(--dsw-alias-state-error,#c33) 30%,transparent)}",
       ".mneme-badge--archived{color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-badge--scope{color:var(--dsw-alias-state-business-primary);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent);border:1px solid color-mix(in srgb,var(--dsw-alias-state-business-primary) 30%,transparent)}",
+      // 冲突集中处理队列（v0.8.0）：状态页的待确认冲突列表
+      ".mneme-conflictq{display:flex;flex-direction:column;gap:10px}",
+      ".mneme-conflictq-head{display:flex;align-items:center;gap:8px}",
+      ".mneme-conflict-item{border:1px solid var(--dsw-alias-border,var(--dsw-alias-interactive-bg-hover));border-radius:10px;padding:10px;display:flex;flex-direction:column;gap:8px}",
+      ".mneme-conflict-reason{font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary)}",
+      ".mneme-conflict-pair{display:grid;grid-template-columns:1fr 1fr;gap:8px}",
+      ".mneme-conflict-side{border:1px solid var(--dsw-alias-border,var(--dsw-alias-interactive-bg-hover));border-radius:8px;padding:8px;display:flex;flex-direction:column;gap:4px;min-width:0}",
+      ".mneme-conflict-sidelabel{font-size:11px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-conflict-sidetitle{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+      ".mneme-conflict-snippet{font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary);display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden}",
+      ".mneme-conflict-missing{font-size:12px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-conflict-actions{display:flex;align-items:center;gap:6px;flex-wrap:wrap}",
+      ".mneme-conflict-hint{font-size:11px;color:var(--dsw-alias-label-tertiary);margin-right:auto}",
       // 详情抽屉：sheet 内右侧滑出，覆盖在浏览区之上
       ".mneme-xmain{position:relative}",
       "@keyframes mneme-slidein{from{opacity:0;transform:translateX(16px)}to{opacity:1;transform:translateX(0)}}",
@@ -1620,7 +1732,9 @@ window.__ModuleLoader__.load({
     const FEATURE_GROUPS = [
       { key: "group.core", items: ["autoInject", "autoSummarize", "hotMemoryEnabled", "memoryQualityFilter.enabled", "llmAudit.enabled"] },
       { key: "group.enhance", items: ["entityExtractionEnabled", "codingRetrospect", "rerankEnabled", "searchSemanticDedup", "bm25SearchEnabled"] },
-      { key: "group.dream", items: ["autoDream", "sleepModeEnabled"] }
+      { key: "group.dream", items: ["autoDream", "sleepModeEnabled"] },
+      // v0.8.0 A4（issue #17）：作用域隔离组——标注总开关 + 严格硬过滤。
+      { key: "group.scope", items: ["scopeEnabled", "strictScope"] }
     ];
     const FEATURE_ADVANCED_BOOLS = ["hybridInject", "selectiveInjectEnabled", "adaptiveThresholdEnabled", "reflectionUpdateEnabled", "reflectionFailureTracking", "conflictFreezeEnabled", "trustEpistemicWeighting"];
     // 字符串键（blur/Enter 提交，空串合法 = 跟随默认）：巩固模型与语义
@@ -1891,6 +2005,7 @@ window.__ModuleLoader__.load({
           savedTick && h("span", { className: "mneme-saved", style: { marginLeft: 8, fontWeight: 400 } }, t("memory.features.restartHint"))
         ),
         h("div", { className: "mneme-set-desc" }, t("memory.features.desc")),
+        h(RuntimeProvisionBlock, { t }),
         state === null && !error
           ? h("div", { className: "mneme-set-hint" }, "…")
           : h(react.Fragment, null,
@@ -2586,8 +2701,89 @@ window.__ModuleLoader__.load({
     }
 
     // 向量索引 — whether semantic recall is switched on.
+    // 取回本地推理运行时的共享块：**面板状态卡片与设置页共用同一份实现**。
+    //
+    // 为什么设置页也要有：状态卡片是「看到了顺手点」，而设置页是用户主动去找的地方。
+    // 两处都给出代价说明与可复制的命令行，并且在**成功后明确要求重启** —— 取回运行时不会让
+    // 当前进程里那个已经失败的 embedder 复活，重启才生效；不说清这一点，用户会以为功能坏了。
+    function RuntimeProvisionBlock({ t, onChanged }) {
+      const [runtime, setRuntime] = useState(null);
+      const [ready, setReady] = useState(null);
+      const [busy, setBusy] = useState(false);
+      const [msg, setMsg] = useState("");
+      const [tick, setTick] = useState(0);
+
+      useEffect(() => {
+        let cancelled = false;
+        apiFetch("/api/dsh-mneme/semantic")
+          .then((res) => (res.ok ? res.json() : null))
+          .then((j) => {
+            if (cancelled || !j) return;
+            setRuntime(j.localRuntime ?? null);
+            setReady(j.ready ?? null);
+          })
+          .catch(() => {});
+        return () => { cancelled = true; };
+      }, [tick]);
+
+      const available = runtime?.status === "available";
+      // 运行时就绪但 embedder 没起来 = 刚取回到、还没重启。这时唯一有意义的动作就是重启。
+      const needsRestart = available && ready !== true;
+
+      const provision = async () => {
+        setBusy(true);
+        setMsg("");
+        try {
+          const res = await apiFetch("/api/dsh-mneme/runtime/provision", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ overwrite: runtime?.status === "broken" })
+          });
+          if (!res.ok) throw new Error("HTTP " + res.status);
+          const j = await res.json();
+          if (j?.ok) {
+            const key = j.strategy === "download"
+              ? "memory.status.vectorRuntimeFetchDownloaded"
+              : "memory.status.vectorRuntimeFetchAdopted";
+            setMsg(t(key).replace("{n}", j.packages ?? 0).replace("{m}", j.files ?? 0).replace("{mode}", j.materialize ?? "?"));
+          } else {
+            setMsg(t("memory.status.vectorRuntimeFetchFailed").replace("{reason}", j?.reason ?? j?.status ?? "?"));
+          }
+          setTick((n) => n + 1);
+          if (onChanged) onChanged();
+        } catch (error) {
+          setMsg(t("memory.status.vectorRuntimeFetchFailed").replace("{reason}", String((error && error.message) || error)));
+        } finally {
+          setBusy(false);
+        }
+      };
+
+      // 配好之后就把整块收起来：设置页只在「需要用户知道或行动」时占地方，配好了就是纯噪音。
+      // （msg 例外：刚点完按钮要看结果，那一刻 ready 还没变，本来也不会命中这条。）
+      if (available && ready === true && msg === "") return null;
+
+      return h(react.Fragment, null,
+        h("div", { className: "mneme-runtimehint" },
+          t("memory.runtime.title") + "：" + (available ? t("memory.runtime.available") : t("memory.runtime.missing"))),
+        // 未就绪时才给代价说明与按钮；已就绪只留上面那行状态（以及在需要重启时下面那行提醒）。
+        available ? null : h(react.Fragment, null,
+          h("div", { className: "mneme-runtimehint" }, t("memory.status.vectorRuntimeCost")),
+          h("button", {
+            type: "button",
+            className: "mneme-footbtn",
+            disabled: busy,
+            onClick: provision
+          }, busy ? t("memory.status.vectorRuntimeFetchBusy") : t("memory.status.vectorRuntimeFetch"))
+        ),
+        msg ? h("div", { className: "mneme-runtimehint" }, msg) : null,
+        needsRestart ? h("div", { className: "mneme-saved" }, t("memory.runtime.restart")) : null
+      );
+    }
     function VectorStatusCard({ t }) {
-      const [state, setState] = useState({ loading: true, error: false, provider: null, ready: null, dimension: 0, embedded: 0, total: 0 });
+      const [state, setState] = useState({ loading: true, error: false, provider: null, ready: null, configured: null, degraded: false, dimension: 0, embedded: 0, total: 0, localRuntime: null });
+      // 收编是写操作、耗时数秒，所以要有忙碌态与就地结果；reload 只是用来让上面的
+      // 加载 useEffect 重跑一次，从而把最新状态拉回来。
+      const [reload, setReload] = useState(0);
       useEffect(() => {
         let cancelled = false;
         // #118: /vector-config is secret-bearing (401 without a stored token →
@@ -2603,34 +2799,77 @@ window.__ModuleLoader__.load({
               error: false,
               provider: j?.embedProvider || null,
               ready: j?.ready ?? null,
+              // issue #135: missing on older servers → null/false，卡片退化成
+              // 旧行为（只按 ready 判断），不会误报「未配置」。
+              configured: typeof j?.configured === "boolean" ? j.configured : null,
+              degraded: j?.degraded === true,
               // Legacy OpenAI embedder exposes dimension only after its first
               // successful embed — fall back to the index stats' dimension.
               dimension: Number(j?.dimension ?? j?.index?.dimension ?? 0),
               embedded: Number(j?.index?.embeddedCount ?? 0),
-              total: Number(j?.index?.totalCount ?? 0)
+              total: Number(j?.index?.totalCount ?? 0),
+              // issue #131: 自管运行时状态。与 provider 无关地拿来，由下面决定是否要展示。
+              localRuntime: j?.localRuntime ?? null
             });
           })
-          .catch(() => { if (!cancelled) setState({ loading: false, error: true, provider: null, ready: null, dimension: 0, embedded: 0 }); });
+          .catch(() => { if (!cancelled) setState({ loading: false, error: true, provider: null, ready: null, dimension: 0, embedded: 0, localRuntime: null }); });
         return () => { cancelled = true; };
-      }, []);
+      }, [reload]);
       const off = !state.provider;
-      const pending = !off && state.ready !== true;
+      // issue #135: 先把「没配」和「配了但在初始化」分开。此前两者都落到
+      // ready !== true，于是未配置的 legacy embedder（ready 恒 true）反而
+      // 一路显示成正常状态。
+      const unconfigured = !off && state.configured === false;
+      const pending = !off && !unconfigured && state.ready !== true;
+      // 配好了、库里有东西、却一条都没嵌上 —— 这才是真正的降级。
+      const degraded = !off && !unconfigured && !pending && state.degraded === true;
+      // 本地 provider 缺运行时：绝不能显示「初始化中」——它永远不会初始化，只会一直重试，
+      // 而那正是那份运行时（数百 MB）缺位的真实原因。这里必须说真话并给出下一步。
+      const localBlocked = /^Local/.test(state.provider || "") && state.localRuntime?.status !== "available" && state.localRuntime != null;
+      // 运行时已就绪但 embedder 还没起来 —— 这就是「刚取回运行时、但进程里的 embedder 早已失败」的过渡态。
+      // 这时候继续说「embedder 不可达，正在重试」会让人以为永远好不了；要说的是可操作的那句：重启 DSH。
+      const runtimeReadyPending = pending && state.localRuntime?.status === "available";
       const num = off
         ? t("memory.status.vectorOff")
-        : pending
-          ? t("memory.status.vectorInit")
-          : `${state.provider.replace(/Embedder$/, "")} · ${state.dimension}D`;
-      const cap = pending
-        ? t("memory.status.vectorInitHint")
-        : off ? "" : t("memory.status.vectorIndexed").replace("{n}", state.embedded).replace("{m}", state.total);
-      return h(StatusCard, {
-        t,
-        title: t("memory.status.vector"),
-        loading: state.loading,
-        error: state.error,
-        num,
-        cap
-      });
+        : localBlocked
+          ? t("memory.status.vectorRuntimeMissing")
+          : unconfigured
+            ? t("memory.status.vectorUnconfigured")
+            : runtimeReadyPending
+              ? t("memory.status.vectorRuntimeReady")
+              : pending
+                ? t("memory.status.vectorInit")
+                : `${state.provider.replace(/Embedder$/, "")} · ${state.dimension}D`;
+      const cap = localBlocked
+        ? t("memory.status.vectorRuntimeHint").replace("{status}", state.localRuntime.status)
+        : unconfigured
+          ? t("memory.status.vectorUnconfiguredHint")
+          : runtimeReadyPending
+            ? t("memory.status.vectorRuntimeReadyHint")
+            : pending
+              ? t("memory.status.vectorInitHint")
+              : off ? ""
+                : degraded
+                  ? t("memory.status.vectorDegradedHint").replace("{m}", state.total)
+                  : t("memory.status.vectorIndexed").replace("{n}", state.embedded).replace("{m}", state.total);
+
+
+      // 取回运行时由共享组件负责（设置页用的是同一份实现，见 RuntimeProvisionBlock）：
+      // 代价说明、三档来源、结果文案与「要重启」都在那里 —— 同一件事不该有两份代码。
+      return h(react.Fragment, null,
+        h(StatusCard, {
+          t,
+          title: t("memory.status.vector"),
+          loading: state.loading,
+          error: state.error,
+          num,
+          cap
+        }),
+        !state.loading && !state.error && localBlocked
+          ? h("div", { className: "mneme-statuscap", style: { marginTop: "6px" } },
+              h(RuntimeProvisionBlock, { t, onChanged: () => setReload((n) => n + 1) }))
+          : null
+      );
     }
 
     // LLM 消耗 — calls + tokens over the trailing 7 days.
@@ -2696,6 +2935,62 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // --- 冲突集中处理队列（v0.8.0，状态页）---------------------------------
+    // 此前冻结冲突只有计数与散落徽章，resolveConflictPending 无任何调用方——
+    // 这里是第一处理入口：并排展示双方内容 + reason，人工选保留方后走
+    // POST /conflicts/resolve（service 端按 dream 非冻结 conflict 同款处置）。
+    // 队列为空时整块不渲染（不打扰无冲突实例）。
+    function ConflictsQueue({ t }) {
+      const [items, setItems] = useState(null);
+      const [busy, setBusy] = useState(false);
+      const load = () => {
+        apiFetch("/api/dsh-mneme/conflicts")
+          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+          .then((d) => setItems(d.items || []))
+          .catch(() => setItems([]));
+      };
+      useEffect(() => { load(); }, []);
+      if (!items || items.length === 0) return null;
+      const resolve = (id, winner) => {
+        setBusy(true);
+        apiFetch("/api/dsh-mneme/conflicts/resolve", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ id, winner, apply: winner !== null })
+        })
+          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+          .then(() => load())
+          .catch(() => {})
+          .finally(() => setBusy(false));
+      };
+      const side = (s, label) => h("div", { className: "mneme-conflict-side" },
+        h("div", { className: "mneme-conflict-sidelabel" }, label),
+        s.missing
+          ? h("div", { className: "mneme-conflict-missing" }, t("memory.status.conflictQueue.missing"))
+          : h(react.Fragment, null,
+              h("div", { className: "mneme-conflict-sidetitle", title: s.title }, s.title || "…"),
+              h("div", { className: "mneme-conflict-snippet" }, (s.content || "").slice(0, 140)),
+              s.archived && h("span", { className: "mneme-badge mneme-badge--archived" }, t("memory.explorer.archivedBadge")))
+      );
+      return h("div", { className: "mneme-conflictq" },
+        h("div", { className: "mneme-conflictq-head" },
+          h("span", { className: "mneme-xcount" }, t("memory.status.conflicts")),
+          h("button", { className: "mneme-footbtn", onClick: () => load() },
+            h(Icon, { name: "refresh", size: 12 }), t("memory.status.conflictQueue.refresh"))),
+        items.map((it) => h("div", { key: it.id, className: "mneme-conflict-item" },
+          it.reason && h("div", { className: "mneme-conflict-reason" },
+            `${t("memory.status.conflictQueue.reason")}: ${it.reason}`),
+          h("div", { className: "mneme-conflict-pair" },
+            side(it.memory_a, t("memory.status.conflictQueue.sideA")),
+            side(it.memory_b, t("memory.status.conflictQueue.sideB"))),
+          h("div", { className: "mneme-conflict-actions" },
+            h("span", { className: "mneme-conflict-hint" }, t("memory.status.conflictQueue.applyHint")),
+            h("button", { className: "mneme-footbtn", disabled: busy, onClick: () => resolve(it.id, "a") }, t("memory.status.conflictQueue.keepA")),
+            h("button", { className: "mneme-footbtn", disabled: busy, onClick: () => resolve(it.id, "b") }, t("memory.status.conflictQueue.keepB")),
+            h("button", { className: "mneme-footbtn", disabled: busy, onClick: () => resolve(it.id, null) }, t("memory.status.conflictQueue.markReviewed"))))
+        ));
+    }
+
     // --- 状态页工作台：让用户切实看见插件在干活 ---
     // 活动流合并 llm_audit 里 autoDream/autoSummarize 的后台调用（状态、
     // token、沉淀条数）；沉淀记忆列表用 audit 行携带的 related_memory_ids
@@ -2886,6 +3181,7 @@ window.__ModuleLoader__.load({
           h(DreamStatusCards, { t }),
           h(HeatStatusCard, { t })
         ),
+        h(ConflictsQueue, { t }),
         h(WorkbenchSection, { t, onBrowse })
       );
     }
@@ -2979,6 +3275,18 @@ window.__ModuleLoader__.load({
             memory.source && h(react.Fragment, null,
               h("span", { className: "mneme-dmetakey" }, t("memory.explorer.source")),
               h("span", { className: "mneme-dmetaval", title: memory.source }, memory.source)),
+            memory.occurred_at && h(react.Fragment, null,
+              h("span", { className: "mneme-dmetakey" }, t("memory.explorer.detail.occurred")),
+              h("span", { className: "mneme-dmetaval", title: memory.occurred_at }, formatDateShort(memory.occurred_at))),
+            memory.agent_scope && h(react.Fragment, null,
+              h("span", { className: "mneme-dmetakey" }, t("memory.explorer.detail.agentScope")),
+              h("span", { className: "mneme-dmetaval", title: memory.agent_scope }, memory.agent_scope)),
+            memory.workspace_scope && h(react.Fragment, null,
+              h("span", { className: "mneme-dmetakey" }, t("memory.explorer.detail.workspaceScope")),
+              h("span", { className: "mneme-dmetaval", title: memory.workspace_scope }, memory.workspace_scope)),
+            memory.sensitivity && h(react.Fragment, null,
+              h("span", { className: "mneme-dmetakey" }, t("memory.explorer.detail.sensitivity")),
+              h("span", { className: "mneme-dmetaval", title: memory.sensitivity }, memory.sensitivity)),
             memory.quality_score != null && h(react.Fragment, null,
               h("span", { className: "mneme-dmetakey" }, t("memory.explorer.detail.quality")),
               h("span", { className: "mneme-dmetaval" }, String(memory.quality_score))),
@@ -3640,6 +3948,7 @@ window.__ModuleLoader__.load({
                         h("div", { className: "mneme-cardfoot" },
                           h(ImportanceStars, { value: m.importance || 0, size: 12 }),
                           h(HeatBadge, { value: m.heat }),
+                          h(ScopeBadge, { m, t }),
                           m.source && h("span", { className: "mneme-cardsrc", title: m.source }, m.source)
                         )
                       )),
@@ -3701,7 +4010,8 @@ window.__ModuleLoader__.load({
                               },
                                 h("span", { className: "mneme-xdot", style: { color: memoryTypeColor(m.type) }, title: typeLabel(t, m.type), "aria-hidden": "true" }),
                                 h("span", { className: "mneme-xtime" }, time),
-                                h("span", { className: "mneme-xname" }, m.title || m.content?.slice(0, 40))
+                                h("span", { className: "mneme-xname" }, m.title || m.content?.slice(0, 40)),
+                                h(ScopeBadge, { m, t })
                               );
                             })
                           ))
@@ -3742,8 +4052,10 @@ window.__ModuleLoader__.load({
 
     // --- Sidebar entry: 工作区上方的记忆按钮 ---
     // 注册仍在 sidebar.footer.action（list 插槽）——它既是 React 树的挂载
-    // 锚点，也是 portal 失效时的原位回退。真实按钮 portal 插到 regionArea
-    // （工作区列表容器）之前，即「新会话」按钮下方、工作区上方。
+    // 锚点，也是 portal 失效时的原位回退。真实按钮 portal 插到「新会话」行
+    // 之后、插件入口组的最前：任务看板/技能中心等生态插件也把入口插在新会话
+    // 行后（它们的后插入者在上），若我们固定在 regionArea 之前就会被打成
+    // 入口组末尾的孤立位（issue #130），所以观察器发现错位就搬回锚点位。
     // 几何对齐方案：读取宿主「新会话」按钮的实时 className 原样套用，再用
     // 我们的修饰类覆盖配色（次级观感）。这样展开态与收起态（rail）都直接
     // 继承宿主自己的盒模型与间距——宿主改版/缩进动画零位移，无需硬编码。
@@ -3770,6 +4082,32 @@ window.__ModuleLoader__.load({
         const findNative = (region) =>
           region.parentElement.querySelector('[class*="newSession"]')
           || region.previousElementSibling;
+        // 占位锚点：新会话行（现役外壳里 newSession 按钮嵌在 logoRow 内，
+        // 旧外壳是根的直接子按钮）。判定与生态插件的 sidebar-entry-core
+        // 一致；锚点不可靠时回退到 regionArea 之前的旧位置。
+        const findAnchor = (region) => {
+          const parent = region.parentElement;
+          const btn = parent.querySelector('[class*="newSession"]');
+          if (!btn) return null;
+          const row = btn.closest('[class*="logoRow"]');
+          if (row && row.parentElement === parent) return row;
+          return btn.parentElement === parent ? btn : null;
+        };
+        // 占位规则：紧跟新会话行（插件入口组的顶部），幂等——已在锚点位就
+        // 不动 DOM。生态插件后插入时会把我们压下去一位，观察器里重排搬回；
+        // 它们只在自身节点被移除时才重插，不会与我们来回争抢。
+        // 注意 created 已紧跟锚点时 target 即 created 自身，必须直接返回：
+        // insertBefore(x, x) 在 Chromium 里不是 no-op，会触发 mutation 造成
+        // 观察器自激风暴、冻死整个 SPA。
+        const place = (region) => {
+          const parent = region.parentElement;
+          if (!parent) return;
+          const anchor = findAnchor(region);
+          const target = anchor ? anchor.nextSibling : region;
+          if (target === created) return;
+          if (created.parentElement === parent && created.nextSibling === target) return;
+          parent.insertBefore(created, target);
+        };
         const attempt = () => {
           const region = document.querySelector('[class*="regionArea"]');
           if (region && region.parentElement) {
@@ -3779,12 +4117,13 @@ window.__ModuleLoader__.load({
             // 否则 portal 按钮会停留在捕获时刻的旧类上（宽度/对齐失配）。
             created = document.createElement("div");
             created.dataset.pluginEntry = "@modusensus/dsh-mneme";
-            region.parentElement.insertBefore(created, region);
+            place(region);
             setHost(created);
             setNativeCls(findNative(region)?.className || "");
             mo = new MutationObserver(() => {
               const cur = document.querySelector('[class*="regionArea"]');
               if (!cur || !cur.parentElement) return;
+              place(cur);
               const cls = findNative(cur)?.className || "";
               setNativeCls((prev) => (prev === cls ? prev : cls));
             });
@@ -3807,10 +4146,8 @@ window.__ModuleLoader__.load({
         };
       }, []);
       if (!host) return fallback;
-      // wrapper 用 display:contents 隐身：我们的按钮成为侧边栏弹性布局的
-      // 直接子元素，与「新会话」按钮同级同距；展开/收起只切换图标与文案。
       return reactDom.createPortal(
-        h("div", { className: "mneme-topentry", style: { display: "contents" } },
+        h("div", { className: "mneme-topentry" },
           h("button", {
             type: "button",
             className: `${nativeCls} mneme-topentry-native`.trim(),
@@ -3901,4 +4238,4 @@ window.__ModuleLoader__.load({
     exports.inject = inject;
     return module.exports;
   }
-});
+});