@modusensus/dsh-mneme 0.7.32 → 0.8.1

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).
@@ -245,6 +270,8 @@ window.__ModuleLoader__.load({
         "memory.settings.feedback.email": "邮件反馈（work@modusensus.space）",
         "memory.settings.feedback.browse": "浏览仓库已知问题",
         "memory.settings.feedback.hint": "反馈前先搜搜是否已有相同问题，能省一份重复的 issue～",
+        "memory.settings.version.outdated": "🆕 有新版本 {v}（当前运行 {c}）",
+        "memory.settings.version.outdatedHint": "若安装时指定过版本号，常规升级不会跨大/小版本（pnpm 钉子）——请重新安装或在升级命令加 --latest；npm 已发布而市场暂未收录属正常（约 1 天延迟）。",
         "memory.settings.mode.title": "运行模式",
         "memory.settings.mode.desc": "轻量模式只保留核心的记忆读写与自动注入（关闭 autoDream 巩固、实体抽取、语义搜索等高级功能），适合只想「记住偏好」的轻量使用；标准模式开启全部功能。",
         "memory.settings.mode.light": "轻量",
@@ -270,6 +297,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 +350,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": "检索与注入硬过滤，只对显式声明的归属生效：显式收窄到他者作用域的记忆不可见；载体自动标注只降权保留可见（真正的物理隔离请用 sensitivity）。重启 DSH 后生效",
         "memory.features.trustEpistemicWeighting": "可信度加权",
         "memory.features.trustEpistemicWeighting.hint": "按来源可信度调整召回排序（实验性）",
         "memory.features.reflectionFailureTracking": "反思失败追踪",
@@ -374,6 +406,17 @@ 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.scopeGlobal": "全局（所有会话可见）",
+        "memory.explorer.detail.scopeSourceAuto": "自动",
+        "memory.explorer.detail.scopeSourceExplicit": "显式",
+        "memory.explorer.detail.scopeEditHint": "留空 = 全局；也可填写具体标签收窄归属",
+        "memory.explorer.detail.scopeWidenConfirm": "确认放宽可见性？",
+        "memory.explorer.detail.scopeWidenHint": "放宽后该记忆将对所有会话可见",
+        "memory.explorer.detail.sensitivity": "敏感度",
+        "memory.explorer.detail.occurred": "发生时间",
         "memory.explorer.detail.edit": "编辑",
         "memory.explorer.detail.save": "保存",
         "memory.explorer.detail.cancel": "取消",
@@ -394,6 +437,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": "总结提炼",
@@ -567,6 +619,8 @@ window.__ModuleLoader__.load({
         "memory.settings.feedback.email": "Email feedback (work@modusensus.space)",
         "memory.settings.feedback.browse": "Browse known issues",
         "memory.settings.feedback.hint": "Search for an existing issue first — it saves a duplicate.",
+        "memory.settings.version.outdated": "🆕 New version {v} available (running {c})",
+        "memory.settings.version.outdatedHint": "If the plugin was installed with a pinned version, regular upgrades never cross minor/major lines — reinstall or pass --latest. A fresh npm release may take about a day to appear in the market.",
         "memory.settings.mode.title": "Runtime mode",
         "memory.settings.mode.desc": "Light mode keeps only the core memory read/write and auto-injection (autoDream consolidation, entity extraction and semantic search are off) — for light use where you just want preferences remembered. Standard mode enables everything.",
         "memory.settings.mode.light": "Light",
@@ -592,6 +646,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",
@@ -644,6 +699,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 for EXPLICITLY declared scopes only: memories explicitly narrowed to other agents/workspaces become invisible; auto carrier labels are demoted but stay visible (use sensitivity for true physical isolation). 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",
@@ -696,6 +755,17 @@ 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.scopeGlobal": "Global (visible to all sessions)",
+        "memory.explorer.detail.scopeSourceAuto": "auto",
+        "memory.explorer.detail.scopeSourceExplicit": "explicit",
+        "memory.explorer.detail.scopeEditHint": "Empty = global; or enter a specific label to narrow the scope",
+        "memory.explorer.detail.scopeWidenConfirm": "Widen visibility?",
+        "memory.explorer.detail.scopeWidenHint": "Widening makes this memory visible to all sessions",
+        "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",
@@ -716,6 +786,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",
@@ -1043,6 +1122,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)}}",
@@ -1655,7 +1748,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 提交，空串合法 = 跟随默认）：巩固模型与语义
@@ -1989,6 +2084,9 @@ window.__ModuleLoader__.load({
       const [apiTokenSaved, setApiTokenSaved] = react.useState(false);
       // 反馈入口的插件版本（GET /info）。失败保持 "unknown"，链接仍可用。
       const [pkgVersion, setPkgVersion] = react.useState("unknown");
+      // 版本自检（#174 后续）：运行版本 vs registry latest。仅 outdated 渲染
+      // 横幅，其余状态（up-to-date / ahead / unknown / 查询失败）零渲染零打扰。
+      const [updateInfo, setUpdateInfo] = react.useState(null);
       // 运行模式 — light vs standard; null = still loading. The card keeps
       // its own busy/saved/error state so it never blocks the others.
       const [mode, setMode] = react.useState(null);
@@ -2034,6 +2132,21 @@ window.__ModuleLoader__.load({
         return () => { cancelled = true; };
       }, []);
 
+      // 版本自检：只读 /version-check（宿主围栏鉴权）。非 outdated 一律归
+      // null——横幅不出现即是「无需处理」；接口失败也静默，不新增故障面。
+      react.useEffect(() => {
+        let cancelled = false;
+        apiFetch("/api/dsh-mneme/version-check")
+          .then((res) => (res.ok ? res.json() : null))
+          .then((j) => {
+            if (!cancelled && j && j.status === "outdated" && typeof j.latest === "string" && typeof j.version === "string") {
+              setUpdateInfo({ latest: j.latest, current: j.version });
+            }
+          })
+          .catch(() => {});
+        return () => { cancelled = true; };
+      }, []);
+
       // 反馈链接预填：环境信息（插件版本 + 平台）+ 问题描述骨架。邮件主题带
       // 版本/平台方便归档，正文同款模板；纯链接零后端成本。
       const feedbackEnv = `**插件版本**: ${pkgVersion}\n**平台**: ${platformLabel()}\n`;
@@ -2244,6 +2357,17 @@ window.__ModuleLoader__.load({
       }
 
       return h("div", null,
+        // 版本自检横幅 — 仅 outdated 时渲染（up-to-date/ahead/unknown/失败
+        // 全部零渲染）。钉子警示：安装时指定过版本号的 profile 会被 pnpm
+        // 挡住常规升级（#174 报障者的实际成因）；市场收录新发布约有 1 天延迟。
+        updateInfo && h("section", { className: "mneme-set-sec" },
+          h("div", { className: "mneme-set-title" },
+            t("memory.settings.version.outdated")
+              .replace("{v}", updateInfo.latest)
+              .replace("{c}", updateInfo.current)
+          ),
+          h("div", { className: "mneme-featsubhint" }, t("memory.settings.version.outdatedHint"))
+        ),
         // 用户画像 — who the agent is talking to
         h("section", { className: "mneme-set-sec" },
           h("div", { className: "mneme-set-title" }, t("memory.settings.profile")),
@@ -2856,6 +2980,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
@@ -3046,6 +3226,7 @@ window.__ModuleLoader__.load({
           h(DreamStatusCards, { t }),
           h(HeatStatusCard, { t })
         ),
+        h(ConflictsQueue, { t }),
         h(WorkbenchSection, { t, onBrowse })
       );
     }
@@ -3055,11 +3236,30 @@ window.__ModuleLoader__.load({
     // 右侧滑出：全文、来源、质量分、关联实体与手动操作（编辑/归档/删除）。
     // 编辑态本地暂存草稿，保存经 POST /update 落库；后端成功后重渲染镜像，
     // 前端只做本地视图同步。两步删除确认在此完成（红钮武装 → 实心红提交）。
+    // v0.8.1 底座（issue #170）：scope 行的来源徽注（显式/自动）。存量行无来源
+    // 时不加后缀——与 A4 的「未标注零视觉变化」同款克制。
+    const scopeSourceSuffix = (t, source) =>
+      source === "explicit" ? ` · ${t("memory.explorer.detail.scopeSourceExplicit")}`
+        : source === "auto" ? ` · ${t("memory.explorer.detail.scopeSourceAuto")}`
+        : "";
+    const scopeProvenanceTitle = (t, source, decidedAt) =>
+      [
+        source === "explicit" ? t("memory.explorer.detail.scopeSourceExplicit")
+          : source === "auto" ? t("memory.explorer.detail.scopeSourceAuto") : null,
+        decidedAt ?? null
+      ].filter(Boolean).join(" · ");
+
     function MemoryDrawer({ t, memory, conflict, deleting, deleteError, onClose, onDelete, onSaved }) {
       const [editing, setEditing] = useState(false);
       const [title, setTitle] = useState(memory.title || "");
       const [content, setContent] = useState(memory.content || "");
       const [importance, setImportance] = useState(memory.importance || 3);
+      // v0.8.1 底座（issue #170）：scope 归属的人工修正入口。空串=放宽到全局
+      // （发送 null），非空=收窄到该标签；只有真的改动才会随 patch 发送并盖
+      // explicit 章——普通编辑不得污染归属来源。
+      const [agentScope, setAgentScope] = useState(memory.agent_scope || "");
+      const [workspaceScope, setWorkspaceScope] = useState(memory.workspace_scope || "");
+      const [confirmWiden, setConfirmWiden] = useState(false);
       const [confirmDelete, setConfirmDelete] = useState(false);
       const [busy, setBusy] = useState(false);
       const [savedTick, setSavedTick] = useState(false);
@@ -3098,7 +3298,25 @@ window.__ModuleLoader__.load({
       const save = () => {
         const t2 = title.trim();
         if (!t2) return;
-        postUpdate({ title: t2, content, importance }, {});
+        const patch = { title: t2, content, importance };
+        const curAgent = memory.agent_scope ?? "";
+        const curWorkspace = memory.workspace_scope ?? "";
+        const nextAgent = agentScope.trim();
+        const nextWorkspace = workspaceScope.trim();
+        const agentChanged = nextAgent !== curAgent;
+        const workspaceChanged = nextWorkspace !== curWorkspace;
+        if (agentChanged) patch.agent_scope = nextAgent || null;
+        if (workspaceChanged) patch.workspace_scope = nextWorkspace || null;
+        // 放宽可见性（标注→全局）必须显式确认（issue #170 的安全阀）：
+        // 第一次点保存只弹确认，再次点「确认放宽」才真正落库。
+        const widening = (curAgent && agentChanged && !nextAgent)
+          || (curWorkspace && workspaceChanged && !nextWorkspace);
+        if (widening && !confirmWiden) {
+          setConfirmWiden(true);
+          return;
+        }
+        setConfirmWiden(false);
+        postUpdate(patch, {});
       };
 
       return h("aside", { className: "mneme-drawer", "aria-label": t("memory.explorer.detail") },
@@ -3139,6 +3357,46 @@ 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))),
+            // v0.8.1 底座：scope 行双态——查看态展示归属 + 来源徽注（显式声明的
+            // 「全局」也渲染，不再因 NULL 而隐身）；编辑态为文本框（留空=全局）。
+            (editing || memory.agent_scope || memory.agent_scope_source === "explicit") && h(react.Fragment, null,
+              h("span", { className: "mneme-dmetakey" }, t("memory.explorer.detail.agentScope")),
+              editing
+                ? h("input", {
+                    type: "text",
+                    className: "mneme-select",
+                    style: { height: 26, fontSize: 12, justifySelf: "start", width: "100%" },
+                    value: agentScope,
+                    placeholder: t("memory.explorer.detail.scopeGlobal"),
+                    title: t("memory.explorer.detail.scopeEditHint"),
+                    onChange: (e) => setAgentScope(e.target.value)
+                  })
+                : h("span", {
+                    className: "mneme-dmetaval",
+                    title: scopeProvenanceTitle(t, memory.agent_scope_source, memory.scope_decided_at) || memory.agent_scope
+                  }, (memory.agent_scope ?? t("memory.explorer.detail.scopeGlobal")) + scopeSourceSuffix(t, memory.agent_scope_source))),
+            (editing || memory.workspace_scope || memory.workspace_scope_source === "explicit") && h(react.Fragment, null,
+              h("span", { className: "mneme-dmetakey" }, t("memory.explorer.detail.workspaceScope")),
+              editing
+                ? h("input", {
+                    type: "text",
+                    className: "mneme-select",
+                    style: { height: 26, fontSize: 12, justifySelf: "start", width: "100%" },
+                    value: workspaceScope,
+                    placeholder: t("memory.explorer.detail.scopeGlobal"),
+                    title: t("memory.explorer.detail.scopeEditHint"),
+                    onChange: (e) => setWorkspaceScope(e.target.value)
+                  })
+                : h("span", {
+                    className: "mneme-dmetaval",
+                    title: scopeProvenanceTitle(t, memory.workspace_scope_source, memory.scope_decided_at) || memory.workspace_scope
+                  }, (memory.workspace_scope ?? t("memory.explorer.detail.scopeGlobal")) + scopeSourceSuffix(t, memory.workspace_scope_source))),
+            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))),
@@ -3168,7 +3426,16 @@ window.__ModuleLoader__.load({
         h("div", { className: "mneme-dactions" },
           editing
             ? h(react.Fragment, null,
-                h("button", { type: "button", className: "mneme-btn", disabled: busy, onClick: save }, t("memory.explorer.detail.save")),
+                confirmWiden
+                  ? h(react.Fragment, null,
+                      h("span", { style: { fontSize: 12, color: "var(--dsw-alias-state-warn,#b8860b)" } },
+                        t("memory.explorer.detail.scopeWidenHint")),
+                      h("button", { type: "button", className: "mneme-btn mneme-btndangerconfirm", disabled: busy, onClick: save },
+                        t("memory.explorer.detail.scopeWidenConfirm")),
+                      h("button", { type: "button", className: "mneme-btn", disabled: busy, onClick: () => setConfirmWiden(false) },
+                        t("memory.explorer.cancel"))
+                    )
+                  : h("button", { type: "button", className: "mneme-btn", disabled: busy, onClick: save }, t("memory.explorer.detail.save")),
                 h("button", {
                   type: "button",
                   className: "mneme-btn",
@@ -3178,6 +3445,9 @@ window.__ModuleLoader__.load({
                     setTitle(memory.title || "");
                     setContent(memory.content || "");
                     setImportance(memory.importance || 3);
+                    setAgentScope(memory.agent_scope || "");
+                    setWorkspaceScope(memory.workspace_scope || "");
+                    setConfirmWiden(false);
                   }
                 }, t("memory.explorer.detail.cancel")),
                 savedTick && h("span", { className: "mneme-saved" }, t("memory.explorer.detail.saved")),
@@ -3800,6 +4070,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)
                         )
                       )),
@@ -3861,7 +4132,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 })
                               );
                             })
                           ))

package/lib/commands.js

@@ -1,11 +1,16 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { STR } from "./lang.js";
 
 // Custom slash-command manager: keeps the DSH command registry in sync with
 // user-defined commands persisted in SQLite. Commands are registered on boot
 // and (re)registered on add/remove through the API.
 //
-// Each custom command's handler returns the user-authored instruction as a
-// success result; the DSH UI surfaces it as a model-directed instruction.
+// Per the DSH command contract, a handler's CommandResult text is only a UI
+// settlement notice and never reaches the model. To actually drive the agent,
+// the handler submits the user-authored instruction itself as a user followup
+// message on the receiving agent (same pattern as the official /goal command).
+// The notice just acknowledges the submission; an optional rawInput suffix
+// typed after the command is appended for the model.
 
 export function createCommandManager({ ctx, settings, logger, language = "zh" }) {
   const registered = new Map(); // name -> disposer
@@ -18,7 +23,8 @@ export function createCommandManager({ ctx, settings, logger, language = "zh" })
         name: command.name,
         // 缺省描述随实例语言（命令描述进命令注册表，对 LLM 可见）。
         description: command.description || STR.commandFallbackDesc[language](command.name),
-        handler: () => ({ kind: "success", text: command.instruction })
+        input: { hint: STR.commandInputHint[language] },
+        handler: (invocation) => submit(command, invocation)
       });
     } catch (error) {
       logger?.warn?.(`dsh-mneme: failed to register command /${command.name}: ${String(error)}`);
@@ -27,6 +33,27 @@ export function createCommandManager({ ctx, settings, logger, language = "zh" })
     registered.set(command.name, dispose);
   }
 
+  /** Submit the instruction (plus optional rawInput suffix) to the receiving agent. */
+  function submit(command, invocation) {
+    const suffix = typeof invocation?.rawInput === "string" ? invocation.rawInput.trim() : "";
+    const text = suffix ? `${command.instruction}\n\n${suffix}` : command.instruction;
+    const agent = invocation?.agent;
+    if (typeof agent?.followup !== "function") {
+      // 兜底：宿主未提供接收 agent 时退回旧行为，至少把指令展示在 notice 里。
+      return { kind: "success", text };
+    }
+    try {
+      agent.followup(createUserMessage({
+        content: [{ type: "text", text }],
+        source: { kind: "user" }
+      }));
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme: failed to submit /${command.name} to agent: ${String(error)}`);
+      return { kind: "error", text: STR.commandSubmitFailed[language](command.name) };
+    }
+    return { kind: "success", text: STR.commandSubmitted[language](command.name) };
+  }
+
   function unregisterOne(name) {
     const dispose = registered.get(name);
     if (dispose) {

package/lib/config.js

@@ -58,6 +58,11 @@ export const Config = z.object({
   // 编码记忆注入加权系数：编码任务时对 rejected_solution/pitfall/constraint
   // 记忆的 importance 乘以该系数排序，让编码记忆在编码场景更靠前。
   codingBoostFactor: z.number().min(1).max(5).default(2),
+  // 注入边界花括号转义（issue #162，v0.7.4 曾修后被 v0.7.11 重构误删）：默认开启，
+  // 在 memory / 短期上下文 / 用户设置三处注入出口对连续 2+ 个花括号插 `\`
+  // （`{{a}}`→`{\{a\}\}`），让 DSH 的 interpolate() 不再扫到非法变量名而 throw。
+  // 关闭时按原样透传。
+  escapePromptVariables: z.boolean().default(true),
   autoDream: z.boolean().default(true),
   dreamThresholdCount: z.natural().min(1).max(1000).default(10),
   dreamThresholdChars: z.natural().min(100).max(100000).default(5000),
@@ -438,6 +443,22 @@ export const Config = z.object({
   recallRecordDefault: z.boolean().default(true),
   // recall_runs 滚动清理保留天数。
   recallRetentionDays: z.natural().min(1).max(3650).default(90),
+
+  // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
+  // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
+  // 逐字节不变。开启后 memory_save 写入 agent_scope（session header 的
+  // agentPreset）与 workspace_scope（registry 反查 canonical path，header.cwd
+  // 兜底，取不到 NULL——解析绝不阻塞写入），去重键扩展为 (type, title,
+  // agent_scope, workspace_scope, sensitivity)。检索侧加权/过滤在 A2/A3 落地。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  scopeEnabled: z.boolean().default(false),
+  // strictScope（A3）：硬过滤模式。关闭=A2 软隔离（他 scope 降权保留可见）；
+  // 开启后检索/注入/list/get 按 issue #17 四象限可见性公式硬过滤——带他 scope
+  // 的记忆完全不可见，未标注（NULL）恒可见；当前会话某维度解析不到时该维度
+  // 带标注的记忆一律不可见（fail-closed：身份不明只见全局）。依赖 scopeEnabled
+  // 打开才有意义（没有写入标注就无可过滤维度），但独立成键：可先开标注积累
+  // 数据、观察 A2 加权质量后再切硬过滤。
+  strictScope: z.boolean().default(false),
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here

package/lib/dream/sleep.js

@@ -4,6 +4,8 @@ import { STR, langOf } from "../lang.js";
 //   1. conflict resolution — high-similarity same-type pairs are either parked
 //      for review (freeze mode) or adjudicated by the LLM (winner kept / loser
 //      archived), reusing the dream conflict machinery. Strictness-graded.
+//      v0.8.1 (issue #170): cross-scope pairs are ALWAYS parked for human
+//      ownership review with a dedicated reason — never auto-adjudicated.
 //   2. archival demotion — memories unreferenced past sleepArchiveDays shrink
 //      to a one-line summary with the full body moved to _full_content; past
 //      sleepCompressDays they are archived outright.
@@ -18,6 +20,7 @@ import { STR, langOf } from "../lang.js";
 import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions, ACTIONS } from "./decisions.js";
 import { findPotentialConflicts, cosineSimilarity } from "./clustering.js";
+import { scopeKeyOf } from "../scope.js";
 import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, maintainIndexAfterDream } from "../dream.js";
 import { computeHeat } from "../heat.js";
 
@@ -169,29 +172,57 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     selected.push(p);
   }
 
-  // Freeze mode: park pairs for manual review, no LLM required.
+  // v0.8.1（issue #170 第 2 步）：跨 scope 相似对分流。同一内容落在两个归属下
+  // （任一维标注键不等即算，NULL=未标注=全局也参与比较——「全局副本 + 专属副本
+  // 并存」正是收窄/提升裁决的典型候选）不能自动裁决：归档败者可能销毁该内容在
+  // 某个归属下的唯一副本，LLM 也无从替用户决定归属。一律停车到冲突待确认队列
+  // （专属 reason），同 scope 对维持既有路径（freeze 停车 / LLM 裁决）。
+  const isCrossScopePair = (p) =>
+    scopeKeyOf(p.a.agent_scope) !== scopeKeyOf(p.b.agent_scope)
+    || scopeKeyOf(p.a.workspace_scope) !== scopeKeyOf(p.b.workspace_scope);
+  const crossPairs = selected.filter(isCrossScopePair);
+  const samePairs = selected.filter((p) => !isCrossScopePair(p));
+  const parkPair = (p, reason) => {
+    try {
+      // 返回 undefined = 该对已被人工裁决且两侧内容未变（复核项 4）——不算停车。
+      return service.saveConflictPending({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, reason }) != null;
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme sleep: failed to park conflict ${p.a.id}/${p.b.id}: ${String(error)}`);
+      return false;
+    }
+  };
+  const scopeReason = (p) => STR.scopeCandidateReason[language](p.similarity.toFixed(2));
+  const simReason = (p) => STR.similarityReason[language](p.similarity.toFixed(2));
+
+  // Freeze mode: park pairs for manual review, no LLM required. Cross-scope
+  // pairs carry the dedicated scope-candidate reason so the queue reads them
+  // as ownership decisions rather than plain duplicates.
   if (config.conflictFreezeEnabled === true) {
     let frozen = 0;
     for (const p of selected) {
-      try {
-        service.saveConflictPending({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, reason: STR.similarityReason[language](p.similarity.toFixed(2)) });
-        frozen++;
-      } catch (error) {
-        logger?.warn?.(`dsh-mneme sleep: failed to freeze conflict ${p.a.id}/${p.b.id}: ${String(error)}`);
-      }
+      if (parkPair(p, isCrossScopePair(p) ? scopeReason(p) : simReason(p))) frozen++;
     }
-    return { status: frozen > 0 ? "ok" : "noop", frozen, pairs: selected.length };
+    return { status: frozen > 0 ? "ok" : "noop", frozen, scopeCandidates: crossPairs.length, pairs: selected.length };
   }
 
-  // LLM adjudication.
+  // 非 freeze：跨 scope 对先停车（绝不进 LLM 裁决），同 scope 对照常走 LLM。
+  let scopeParked = 0;
+  for (const p of crossPairs) {
+    if (parkPair(p, scopeReason(p))) scopeParked++;
+  }
+  if (samePairs.length === 0) {
+    return { status: scopeParked > 0 ? "ok" : "noop", frozen: 0, scopeCandidates: scopeParked, pairs: selected.length };
+  }
+
+  // LLM adjudication（仅同 scope 对）。
   const route = resolveSleepRoute(ctx, config, logger);
-  if (!route) return { status: "skipped", reason: "no llm route" };
+  if (!route) return { status: "skipped", reason: "no llm route", scopeCandidates: scopeParked, pairs: selected.length };
   const snapshot = new Map();
-  for (const p of selected) {
+  for (const p of samePairs) {
     snapshot.set(p.a.id, p.a);
     snapshot.set(p.b.id, p.b);
   }
-  const listText = selected.map((p) =>
+  const listText = samePairs.map((p) =>
     STR.candidateConflicts[language](p)
   ).join("\n\n");
   const sleepEffort = await resolveDreamEffort(ctx, route, config.sleepReasoningEffort, logger);