dsh-mnemon-source-memory-spaces 0.5.11 → 0.5.13

package/lib/index.js

@@ -1,4 +1,4 @@
-import { findMnemonCommand, isMnemonExecutable, mnemonNpmLauncher, nodeLauncherEnvironment } from "./native-cli.js";
+import { findMnemonCommand, isMnemonExecutable, resolveMnemonInvocation } from "./native-cli.js";
 import { CATEGORIES as CATEGORIES$1, EDGE_TYPES, INTENTS as INTENTS$1, MNEMON_EMBEDDING_PROTOCOLS, SOURCES as SOURCES$1 } from "./contracts.js";
 import { a as MemoryProviderCatalog, i as EMPTY_MEMORY_PROVIDER_CATALOG, n as PrivateMemorySpaceProviderHost, r as MemoryProviderAdapterRegistry, t as createMemorySpaceProviderPlugin } from "./plugin-DlsNeZbQ.js";
 import { t as runProcess } from "./process-BvrgxPNP.js";
@@ -1374,6 +1374,17 @@ var MemorySpacesService = class {
 	recallQualityPolicy;
 	spacesInFlight;
 	providersDisposed = false;
+	/** The CLI version a full status last read, and the binary it read it from. */
+	cliVersion;
+	/** The CLI binary as the file system has it; another value after an update replaces it. */
+	cliBinary() {
+		try {
+			const stat = statSync(this.runner.command);
+			return `${this.runner.command}\0${stat.mtimeMs}\0${stat.size}`;
+		} catch {
+			return;
+		}
+	}
 	providerTypeId(providerId) {
 		const catalog = this.providerCatalog;
 		if (!catalog.has(providerId)) return providerId;
@@ -1524,6 +1535,7 @@ var MemorySpacesService = class {
 	/** Return a usable system snapshot without waiting for any Provider I/O. */
 	statusSummary() {
 		const catalog = this.spaceDirectory();
+		const version = this.cliVersion !== void 0 && this.cliBinary() === this.cliVersion.binary ? this.cliVersion.version : void 0;
 		const dshActiveStores = catalog.items.filter((body) => body.active && body.providerEnabled !== false).map((body) => body.id);
 		const providerServices = this.memorySpaces.providerServices().items.map((service) => {
 			const descriptor = this.providerCatalog.descriptor(service.providerId);
@@ -1554,7 +1566,8 @@ var MemorySpacesService = class {
 			recallQuality: this.config.recallQuality,
 			memoryBodyDirectory: catalog.directory,
 			memoryBodies: catalog.items,
-			providerServices
+			providerServices,
+			...version === void 0 ? {} : { version }
 		};
 	}
 	/** Probe the effective Mnemon embedding runtime and its default Store coverage. */
@@ -1620,6 +1633,12 @@ var MemorySpacesService = class {
 			memoryBodies: catalog.items,
 			providerServices
 		};
+		const version = rawVersion === void 0 ? void 0 : rawVersion.trim().replace(/^mnemon version\s+/i, "");
+		const binary = version === void 0 ? void 0 : this.cliBinary();
+		this.cliVersion = version === void 0 || binary === void 0 ? void 0 : {
+			binary,
+			version
+		};
 		try {
 			const healthySpaces = active.filter((body) => body.healthy && body.stats !== void 0);
 			const topEntities = /* @__PURE__ */ new Map();
@@ -1645,7 +1664,7 @@ var MemorySpacesService = class {
 			return {
 				healthy: true,
 				...base,
-				...rawVersion === void 0 ? {} : { version: rawVersion.trim().replace(/^mnemon version\s+/i, "") },
+				...version === void 0 ? {} : { version },
 				stats,
 				...errors.length === 0 ? {} : { error: errors.join("; ") }
 			};
@@ -2387,11 +2406,10 @@ function createRunner(config, processRunner = runProcess) {
 		};
 		let result;
 		try {
-			const command = currentCommand();
-			const launcher = mnemonNpmLauncher(command);
-			result = await processRunner(launcher === void 0 ? command : process.execPath, launcher === void 0 ? argv : [launcher, ...argv], launcher === void 0 ? processOptions : {
+			const invocation = resolveMnemonInvocation(currentCommand(), argv, environment);
+			result = await processRunner(invocation.command, invocation.args, {
 				...processOptions,
-				env: nodeLauncherEnvironment(processOptions.env)
+				...invocation.env === void 0 ? {} : { env: invocation.env }
 			});
 		} catch (error) {
 			throw new MnemonCliError(`${error instanceof Error ? error.message : String(error)}. ${process.platform === "win32" ? "Install the official Mnemon Windows release, ensure mnemon.exe is on PATH or under %LOCALAPPDATA%\\Programs\\mnemon, or set MNEMON_CLI_PATH or mnemon.cliPath to its absolute path." : "Install Mnemon and ensure \"mnemon\" is on PATH, or set MNEMON_CLI_PATH or mnemon.cliPath."}`);

package/lib/native-cli.d.ts

@@ -2,6 +2,12 @@
 /** Execute JavaScript with the Host binary even when it is Electron's GUI executable. */
 declare function nodeLauncherEnvironment(environment?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 declare function mnemonNpmLauncher(command: string): string | undefined;
+/** Keep CLI subprocesses under our windowsHide, timeout and cancellation policy. */
+declare function resolveMnemonInvocation(command: string, args: readonly string[], env?: NodeJS.ProcessEnv): {
+  command: string;
+  args: string[];
+  env?: NodeJS.ProcessEnv;
+};
 interface CommandDiscoveryOptions {
   platform?: NodeJS.Platform;
   env?: NodeJS.ProcessEnv;
@@ -14,4 +20,4 @@ declare function findMnemonCommand(config: {
   cliPath?: string | undefined;
 }, options?: CommandDiscoveryOptions): string | undefined;
 //#endregion
-export { CommandDiscoveryOptions, findMnemonCommand, isMnemonExecutable, mnemonNpmLauncher, nodeLauncherEnvironment };
+export { CommandDiscoveryOptions, findMnemonCommand, isMnemonExecutable, mnemonNpmLauncher, nodeLauncherEnvironment, resolveMnemonInvocation };

package/lib/native-cli.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import { accessSync, constants, existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, posix, win32 } from "node:path";
@@ -38,6 +39,42 @@ function mnemonNpmLauncher(command) {
 		} catch {}
 	}
 }
+/** Resolve only the platform package pinned by the recognized official launcher. */
+function npmNativeBinary(launcher) {
+	const pkg = manifest(join(dirname(dirname(launcher)), "package.json"));
+	const target = `${process.platform}-${process.arch}`;
+	const alias = `${MNEMON_NPM_PACKAGE}-${target}`;
+	const version = typeof pkg?.version === "string" ? `${pkg.version}-${target}` : void 0;
+	if (version === void 0 || pkg?.optionalDependencies?.[alias] !== `npm:${MNEMON_NPM_PACKAGE}@${version}`) return void 0;
+	try {
+		const packagePath = createRequire(launcher).resolve.paths(alias)?.map((path) => join(path, alias, "package.json")).find(existsSync);
+		if (packagePath === void 0) return void 0;
+		const native = manifest(packagePath);
+		if (native?.name !== MNEMON_NPM_PACKAGE || native.version !== version) return void 0;
+		const binary = join(dirname(packagePath), "bin", process.platform === "win32" ? "mnemon.exe" : "mnemon");
+		return isMnemonExecutable(binary) ? binary : void 0;
+	} catch {
+		return;
+	}
+}
+/** Keep CLI subprocesses under our windowsHide, timeout and cancellation policy. */
+function resolveMnemonInvocation(command, args, env) {
+	const launcher = mnemonNpmLauncher(command);
+	if (launcher !== void 0) {
+		const binary = args.length === 1 && args[0] === "update" ? void 0 : npmNativeBinary(launcher);
+		if (binary === void 0) return {
+			command: process.execPath,
+			args: [launcher, ...args],
+			env: nodeLauncherEnvironment(env)
+		};
+		command = binary;
+	}
+	return {
+		command,
+		args: [...args],
+		...env === void 0 ? {} : { env }
+	};
+}
 const UNIX_COMMON_CLI_PATHS = [
 	"~/.local/bin/mnemon",
 	"/opt/homebrew/bin/mnemon",
@@ -112,4 +149,4 @@ function findMnemonCommand(config, options = {}) {
 	for (const path of commonCliPaths(platform, env, home)) if (isExecutable(path)) return path;
 }
 //#endregion
-export { findMnemonCommand, isMnemonExecutable, mnemonNpmLauncher, nodeLauncherEnvironment };
+export { findMnemonCommand, isMnemonExecutable, mnemonNpmLauncher, nodeLauncherEnvironment, resolveMnemonInvocation };

package/lib/types/client/pages.d.ts

@@ -16,6 +16,7 @@ export declare function OverviewPage(props: {
     client: MemorySpacesPageClient;
     metadataClient: MemorySpacesPageClient;
     revision: number;
+    reloadKey?: number;
     activationEnabled: boolean;
     writeEnabled: boolean;
     agentAvailable: boolean;
@@ -61,7 +62,7 @@ export declare function RememberPage(props: {
     seed: string;
     onMutate: () => void;
     onClose: () => void;
-    onComplete?: () => void;
+    onView?: () => void;
 }): JSX.Element;
 export declare function ListPage(props: {
     client: MemorySpacesPageClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon-source-memory-spaces",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "Memory Spaces Source and its private Provider SDK.",
   "license": "MIT",
   "type": "module",
@@ -55,8 +55,8 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.7-rc.2",
-    "dsh-mnemon": "^0.5.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.7-rc.2 || ^0.2.0-rc.1",
+    "dsh-mnemon": "^0.5.19",
     "react": "^18.2.0"
   },
   "devDependencies": {
@@ -65,13 +65,13 @@
     "@types/node": "^22.0.0",
     "@types/react": "^18.3.0",
     "@types/react-dom": "^18.3.0",
-    "dsh-mnemon": "^0.5.17",
+    "dsh-mnemon": "^0.5.19",
     "dsh-mnemon-provider-byterover": "^0.5.5",
     "dsh-mnemon-provider-hindsight": "^0.5.5",
     "dsh-mnemon-provider-holographic": "^0.5.5",
     "dsh-mnemon-provider-honcho": "^0.5.5",
     "dsh-mnemon-provider-mem0": "^0.5.5",
-    "dsh-mnemon-provider-mnemon-native": "^0.5.6",
+    "dsh-mnemon-provider-mnemon-native": "^0.5.7",
     "dsh-mnemon-provider-openviking": "^0.5.7",
     "dsh-mnemon-provider-retaindb": "^0.5.5",
     "dsh-mnemon-provider-supermemory": "^0.5.5",

package/presentation/locales.json

@@ -13,10 +13,10 @@
     "nav.bodies": "记忆空间",
     "nav.search": "检索",
     "nav.entities": "实体",
-    "nav.rememberAction": "沉淀记忆",
+    "nav.rememberAction": "存入记忆",
     "nav.content": "内容",
     "overview.title": "记忆空间",
-    "overview.description": "统一管理由 Mnemon Native 或第三方 Provider 承载的记忆空间；已激活的空间共同参与读取、路由与实时快照。",
+    "overview.description": "由 Mnemon Native 或第三方 Provider 承载的长期记忆；已激活的空间参与召回。",
     "overview.pageDescription": "创建和启停记忆空间，查看每个 Provider 的存储状态与实时关联快照。",
     "overview.interval": "进入时全量同步 · 点击卡片按需同步",
     "overview.fullSyncPending": "等待首次全量同步",
@@ -25,11 +25,8 @@
     "overview.fullSyncMinutes": "上次全量同步：{count} 分钟前",
     "overview.fullSyncHours": "上次全量同步：{count} 小时前",
     "overview.fullSyncDays": "上次全量同步：{count} 天前",
-    "overview.syncing": "同步中…",
-    "overview.syncNow": "立即同步",
     "overview.directory": "记忆空间目录",
-    "overview.directory.description": "每张卡片对应一个记忆空间。第三方 Provider 首次接入时建立映射，之后点击卡片只检测该空间；本地维护的标题与说明不会被重连覆盖。",
-    "overview.directory.waiting": "等待目录",
+    "overview.directory.description": "每张卡片是一个记忆空间；点击卡片检查连接，开关决定它是否参与召回。",
     "overview.directory.unsynced": "目录尚未同步",
     "overview.directory.unsyncedBadge": "目录待同步",
     "overview.directoryLoading": "正在加载记忆空间目录",
@@ -41,7 +38,7 @@
     "overview.reconnectHint": "点击卡片重新检测并同步这个记忆空间",
     "overview.reconnectAria": "重新连接{name}",
     "overview.snapshotLoading": "正在加载多记忆空间实时快照",
-    "overview.metadataAction": "AI 维护元信息",
+    "overview.metadataAction": "整理名称与说明",
     "overview.metadataTitle": "AI 维护记忆空间元信息",
     "overview.metadataDescription": "选择一个或多个已激活记忆空间。系统会分别通过各 Provider 最快的原生查询路径读取少量样本，再由独立任务 Agent 生成标题与说明。",
     "overview.metadataUnavailable": "暂时无法运行：未找到与当前记忆范围匹配的活跃 Agent",
@@ -72,13 +69,13 @@
     "overview.noActiveTitle": "没有激活的记忆空间",
     "overview.noActiveText": "开启至少一个记忆空间的读取开关，即可在这里聚合它的实时图谱。",
     "overview.noContentTitle": "已激活记忆空间尚无内容",
-    "overview.noContentText": "向任意记忆空间沉淀稳定上下文后，这里会聚合呈现节点与关系。",
+    "overview.noContentText": "存入记忆后，这里会显示节点与关系。",
     "overview.createTitle": "创建记忆空间",
     "overview.createDialogHint": "这里定义记忆空间用途并选择底层 Provider；服务、凭据和全局数据位置沿用“插件 → 可组合记忆”页面中的配置。",
     "overview.createIdentityTitle": "记忆空间信息",
     "overview.createIdentityHint": "名称用于识别；描述会帮助 Agent 判断什么内容应写入和召回。",
     "overview.createPlacementTitle": "记忆空间 Provider",
-    "overview.createPlacementHint": "这是一次明确的手动创建；选择一个已启用 Provider。自动选择由“沉淀策略”统一管理。",
+    "overview.createPlacementHint": "这是一次明确的手动创建；选择一个已启用 Provider。任务 Agent 新建空间时的选择在“新空间的 Provider”中设置。",
     "overview.createName": "新记忆空间名称",
     "overview.createNamePlaceholder": "名称",
     "overview.createDescription": "新记忆空间描述",
@@ -107,7 +104,7 @@
     "overview.capability.exact-write": "精确写入",
     "overview.capability.forget": "安全遗忘",
     "overview.candidateNativeReady": "官方原生 · 跟随当前记忆范围",
-    "overview.providerServiceRequired": "尚未启用；请先在“插件 → 可组合记忆”页面完成服务配置",
+    "overview.providerServiceRequired": "未启用",
     "overview.nativeCliRequired": "需要在本机安装 Mnemon CLI；其他 Provider 不受影响",
     "overview.workspaceBinding.automatic": "跟随当前记忆范围",
     "overview.workspaceBinding.optional-override": "跟随当前范围；全局可自定义位置",
@@ -124,21 +121,19 @@
     "overview.providerLabel": "记忆引擎",
     "overview.nativeOfficial": "官方原生",
     "overview.providerNativeHint": "官方原生、本地优先，保留完整图谱与软删除能力",
-    "strategy.action": "沉淀策略",
-    "strategy.title": "沉淀策略",
-    "strategy.description": "定义 Agent 在沉淀过程中需要新建记忆空间时，如何选择底层 Provider。已有记忆空间仍会优先按名称、描述与能力路由。",
+    "strategy.action": "新空间的 Provider",
+    "strategy.title": "新空间的 Provider",
+    "strategy.description": "任务 Agent 需要新建记忆空间时，如何选择 Provider；已有空间仍按名称与说明路由。",
     "strategy.loading": "正在读取 Provider 目录…",
     "strategy.modeTitle": "Provider 选择方式",
-    "strategy.modeHint": "该策略只影响 Agent 沉淀时的新记忆空间创建；手动点击“创建记忆空间”始终由你指定。",
+    "strategy.modeHint": "只影响任务 Agent 新建的记忆空间；手动创建时始终由你指定。",
     "strategy.manualHint": "固定使用一个 Provider，Agent 无法改选",
     "strategy.automaticHint": "先执行硬规则，再由任务 Agent 选择合格 Provider",
     "strategy.manualTitle": "固定 Provider",
     "strategy.manualDescription": "当现有记忆空间都不适合时，新记忆空间固定创建在这个 Provider 中。",
     "strategy.automaticTitle": "智能选择规则",
     "strategy.automaticDescription": "数据边界与能力要求由主机强制执行，Prompt 只影响合格候选之间的判断。",
-    "strategy.taskAgentReady": "任务 Agent 就绪",
-    "strategy.taskAgentUnavailable": "等待任务 Agent",
-    "strategy.save": "保存策略",
+    "strategy.save": "保存",
     "strategy.saving": "保存中…",
     "overview.providerOpenVikingHint": "连接已有 OpenViking 服务，由记忆空间工作流统一调度",
     "overview.providerSummary.mnemon-native": "官方原生、本地优先，保留完整图谱与软删除能力",
@@ -256,7 +251,7 @@
     "graph.kindSpace": "记忆空间",
     "graph.kindEntity": "实体",
     "search.title": "检索记忆",
-    "search.description": "跨已激活记忆空间检索原始证据；每个 Provider 使用自己的原生召回方式并保留来源。",
+    "search.description": "在已激活的记忆空间中检索：直接检索返回原文，Agent 查询给出带引用的回答。",
     "search.maxResults": "最多 {count} 条",
     "search.placeholder": "为什么选用 SQLite？这个项目有哪些发布约定？",
     "search.queryAria": "记忆查询",
@@ -283,7 +278,7 @@
     "search.noRelated": "没有找到两跳内的关联节点。",
     "search.sourcesTitle": "本次检索范围",
     "entities.title": "实体查阅",
-    "entities.description": "只在真正提供实体索引的记忆空间中，查阅实体跨越事实、决策与上下文的关系。",
+    "entities.description": "查看实体在事实、决策与上下文之间的关联。",
     "entities.sourcesTitle": "实体能力范围",
     "entities.unsupportedTitle": "没有支持实体索引的记忆空间",
     "entities.unsupportedText": "当前激活 Provider 仍可通过“检索”召回，但不会在这里伪装成实体图谱。",
@@ -301,52 +296,41 @@
     "entities.selectText": "实体视图会聚合与它相关的记忆，而不是只做字面匹配。",
     "entities.emptyTitle": "没有关联记忆",
     "entities.emptyText": "尝试更完整的名称或另一个实体别名。",
-    "remember.title": "沉淀记忆",
-    "remember.description": "候选内容会进入无会话历史的独立任务 Agent，由它选择记忆空间、查重、提炼并执行写入，不占用主对话上下文。",
+    "remember.title": "存入记忆",
+    "remember.description": "任务 Agent 会判断是否值得保存，去重、提炼后写入合适的记忆空间，不占用当前对话。",
     "remember.readOnlyTitle": "当前为只读模式",
     "remember.readOnlyText": "当前部署禁止记忆写入；如需调整，请修改 DSH 的 Mnemon 配置并保存。",
-    "remember.delegateTitle": "交给独立任务 Agent",
-    "remember.noSession": "无可用会话",
-    "remember.ready": "独立任务 Agent 就绪",
-    "remember.noTaskAgent": "任务 Agent 不可用",
-    "remember.taskAgentReady": "任务 Agent 就绪",
     "remember.candidate": "候选内容",
-    "remember.candidateAria": "待沉淀内容",
-    "remember.placeholder": "输入希望跨任务保留的背景、偏好、决策或洞察。模型会先判断它是否真的值得沉淀。",
+    "remember.placeholder": "输入希望长期保留的背景、偏好、决策或结论。",
     "remember.sessionHint": "当前视图没有可用的模型路由，无法创建独立任务 Agent。",
     "remember.taskAgentHint": "当前 Host 暂时无法创建独立任务 Agent，请刷新状态后重试。",
-    "remember.processing": "独立任务 Agent 处理中…",
-    "remember.action": "调度独立任务 Agent 判断并沉淀",
-    "remember.advanced": "人工高级选项",
-    "remember.advancedHint": "为独立任务 Agent 指定目标记忆空间与元数据约束",
+    "remember.processing": "任务 Agent 处理中…",
+    "remember.action": "交给任务 Agent",
+    "remember.advanced": "高级选项",
+    "remember.advancedHint": "指定目标记忆空间、分类与重要性",
     "remember.expand": "展开",
     "remember.target": "目标记忆空间",
     "remember.asyncProviderHint": "该记忆空间会等待远程提炼任务完成后再返回真实写入回执。",
     "remember.entities": "实体（逗号分隔）",
     "remember.tags": "标签（逗号分隔）",
-    "remember.advancedText": "高级选项是约束而不是绕过监督；独立任务 Agent 仍会查重并返回结构化回执。",
-    "remember.saving": "独立任务 Agent 写入中…",
-    "remember.advancedAction": "按高级约束沉淀",
-    "remember.skipped": "独立任务 Agent 判断无需写入",
-    "remember.completed": "独立任务 Agent 已完成处理",
-    "remember.processed": "独立任务 Agent 已处理：{action}",
-    "remember.dispatchFailed": "调度失败：{error}",
-    "remember.saveFailed": "保存失败：{error}",
+    "remember.advancedText": "这些约束同样经过任务 Agent 的去重与回执。",
+    "remember.saving": "任务 Agent 处理中…",
+    "remember.advancedAction": "按约束交给任务 Agent",
     "content.title": "记忆内容",
-    "content.description": "按 Provider 的真实浏览契约检查可观察内容；列表型、查询型与不可浏览引擎会明确区分。",
+    "content.description": "浏览各记忆空间保存的内容。",
     "content.sourcesTitle": "Provider 内容模型",
     "content.count": "{count} 条记忆",
     "content.filterAria": "筛选记忆内容",
     "content.filterPlaceholder": "按内容或精确 ID 筛选…",
     "content.categoryAria": "记忆分类",
     "content.apply": "应用筛选",
-    "content.notice": "内容页直接调用 Provider 的只读浏览契约；查询型引擎仅在输入查询后执行检索。",
+    "content.notice": "查询型 Provider 需要输入关键词后才显示内容。",
     "content.queryRequiredTitle": "查询型记忆空间等待问题",
     "content.queryRequiredText": "输入一个明确查询即可读取 ByteRover 等不提供全量列表的 Provider。",
     "content.showing": "当前显示 {visible} / {total}",
     "content.showMore": "再显示 {count} 条",
     "content.emptyTitle": "没有符合条件的记忆",
-    "content.emptyText": "清空筛选，或前往“沉淀”写入第一条稳定上下文。",
+    "content.emptyText": "清空筛选，或先存入第一条记忆。",
     "nav.spaces": "记忆空间",
     "overview.editSpace": "编辑",
     "overview.editSpaceAria": "编辑{name}",
@@ -356,7 +340,10 @@
     "overview.deleteSpaceAria": "删除{name}",
     "overview.disconnectSpace": "断开",
     "overview.disconnectSpaceAria": "断开{name}",
-    "overview.deletingSpace": "删除中…"
+    "overview.deletingSpace": "删除中…",
+    "common.score": "相关度 {value}",
+    "overview.providerEnableHint": "未启用的 Provider 可在“插件 → 可组合记忆”的“记忆空间”页面中启用。",
+    "search.citations": "引用"
   },
   "en": {
     "term.space": "Memory Space",
@@ -372,10 +359,10 @@
     "nav.bodies": "Memory Spaces",
     "nav.search": "Recall",
     "nav.entities": "Entities",
-    "nav.rememberAction": "Remember",
+    "nav.rememberAction": "Save to memory",
     "nav.content": "Content",
     "overview.title": "Memory Spaces",
-    "overview.description": "Manage memory spaces backed by Mnemon Native or third-party Providers. Active spaces participate in reads, routing, and live snapshots.",
+    "overview.description": "Long-term memory held by Mnemon Native or third-party Providers; active spaces take part in recall.",
     "overview.pageDescription": "Create and activate Memory Spaces, then inspect storage health and live relation snapshots across providers.",
     "overview.interval": "Full sync on entry · Click a card to sync on demand",
     "overview.fullSyncPending": "Waiting for the first full sync",
@@ -384,11 +371,8 @@
     "overview.fullSyncMinutes": "Last full sync: {count}m ago",
     "overview.fullSyncHours": "Last full sync: {count}h ago",
     "overview.fullSyncDays": "Last full sync: {count}d ago",
-    "overview.syncing": "Syncing…",
-    "overview.syncNow": "Sync now",
     "overview.directory": "Memory Space Directory",
-    "overview.directory.description": "Each card represents a memory space. A third-party Provider creates its mapping on first connection; later card clicks check only that space, without overwriting locally maintained titles or descriptions.",
-    "overview.directory.waiting": "Waiting for directory",
+    "overview.directory.description": "Each card is one Memory Space; click it to check the connection, and use its switch to include it in recall.",
     "overview.directory.unsynced": "Directory not synchronized",
     "overview.directory.unsyncedBadge": "Directory pending",
     "overview.directoryLoading": "Loading the Memory Space directory",
@@ -400,7 +384,7 @@
     "overview.reconnectHint": "Click the card to reconnect and synchronize this Memory Space",
     "overview.reconnectAria": "Reconnect {name}",
     "overview.snapshotLoading": "Loading the multi-space live snapshot",
-    "overview.metadataAction": "AI metadata",
+    "overview.metadataAction": "Tidy names and descriptions",
     "overview.metadataTitle": "Maintain Memory Space metadata with AI",
     "overview.metadataDescription": "Select one or more active Memory Spaces. The system reads a small sample through each Provider’s fastest native path, then gives each space to an independent task Agent for its title and description.",
     "overview.metadataUnavailable": "Temporarily unavailable: no active Agent matches the current memory scope",
@@ -431,13 +415,13 @@
     "overview.noActiveTitle": "No active Memory Spaces",
     "overview.noActiveText": "Enable read access for at least one space to aggregate its live graph here.",
     "overview.noContentTitle": "Active spaces have no content yet",
-    "overview.noContentText": "Distill durable context into a space to populate nodes and relations.",
+    "overview.noContentText": "Save memories to see their nodes and relations here.",
     "overview.createTitle": "Create Memory Space",
     "overview.createDialogHint": "Define this Memory Space and choose its provider here. It reuses services, credentials, and global data locations configured on the dsh-mnemon page under Plugins.",
     "overview.createIdentityTitle": "Memory Space details",
     "overview.createIdentityHint": "The name identifies the space; the description guides when the agent writes and recalls it.",
     "overview.createPlacementTitle": "Memory Space provider",
-    "overview.createPlacementHint": "This is an explicit manual creation. Choose one enabled Provider; automatic selection is managed by Distillation Strategy.",
+    "overview.createPlacementHint": "This is an explicit manual creation; choose one enabled Provider. What a task Agent chooses for new spaces is set in Provider for new spaces.",
     "overview.createName": "New Memory Space name",
     "overview.createNamePlaceholder": "Name",
     "overview.createDescription": "New Memory Space description",
@@ -466,7 +450,7 @@
     "overview.capability.exact-write": "Exact writes",
     "overview.capability.forget": "Safe forget",
     "overview.candidateNativeReady": "Official native · follows the active memory scope",
-    "overview.providerServiceRequired": "Not enabled; configure the service on the dsh-mnemon page under Plugins first",
+    "overview.providerServiceRequired": "Off",
     "overview.nativeCliRequired": "Needs the Mnemon CLI on this machine; other providers work without it",
     "overview.workspaceBinding.automatic": "Follows the active memory scope",
     "overview.workspaceBinding.optional-override": "Follows the active scope; global location can be customized",
@@ -483,21 +467,19 @@
     "overview.providerLabel": "Memory engine",
     "overview.nativeOfficial": "Official native",
     "overview.providerNativeHint": "Official native, local-first storage with the full graph and soft-delete semantics",
-    "strategy.action": "Distillation strategy",
-    "strategy.title": "Distillation strategy",
-    "strategy.description": "Choose how the Agent selects a Provider when it must create a new Memory Space during distillation. Existing spaces are still routed by name, description, and capabilities first.",
+    "strategy.action": "Provider for new spaces",
+    "strategy.title": "Provider for new spaces",
+    "strategy.description": "How a task Agent picks a Provider when it creates a Memory Space; existing spaces are still chosen by name and description.",
     "strategy.loading": "Loading Provider directory…",
     "strategy.modeTitle": "Provider selection",
-    "strategy.modeHint": "This policy applies only to Agent-created spaces during distillation. Manual Create Memory Space always asks you to choose.",
+    "strategy.modeHint": "Applies only to spaces a task Agent creates; you always choose when you create one yourself.",
     "strategy.manualHint": "Fix one Provider; the Agent cannot override it",
     "strategy.automaticHint": "Apply hard rules first, then let the task Agent choose an eligible Provider",
     "strategy.manualTitle": "Fixed Provider",
     "strategy.manualDescription": "When no existing space fits, create the new space on this Provider.",
     "strategy.automaticTitle": "Smart selection rules",
     "strategy.automaticDescription": "The host enforces data and capability rules. The prompt only guides judgment among eligible candidates.",
-    "strategy.taskAgentReady": "Task Agent ready",
-    "strategy.taskAgentUnavailable": "Waiting for task Agent",
-    "strategy.save": "Save strategy",
+    "strategy.save": "Save",
     "strategy.saving": "Saving…",
     "overview.providerOpenVikingHint": "Connect an existing OpenViking service under the same Memory Space workflow",
     "overview.providerSummary.mnemon-native": "Official native, local-first storage with the full graph and soft-delete semantics",
@@ -615,7 +597,7 @@
     "graph.kindSpace": "Memory Space",
     "graph.kindEntity": "Entity",
     "search.title": "Recall Memory",
-    "search.description": "Retrieve raw evidence across active Memory Spaces; every provider uses its native recall method and keeps provenance.",
+    "search.description": "Search the active Memory Spaces: direct search returns the stored text, an Agent query answers with citations.",
     "search.maxResults": "Up to {count} results",
     "search.placeholder": "Why did we choose SQLite? What release conventions apply?",
     "search.queryAria": "Memory query",
@@ -642,7 +624,7 @@
     "search.noRelated": "No related nodes found within two hops.",
     "search.sourcesTitle": "Search coverage",
     "entities.title": "Entity Explorer",
-    "entities.description": "Inspect entity connections only in Memory Spaces that expose a real entity index.",
+    "entities.description": "See how entities connect facts, decisions and context.",
     "entities.sourcesTitle": "Entity capability coverage",
     "entities.unsupportedTitle": "No active space exposes an entity index",
     "entities.unsupportedText": "The active providers remain searchable through Recall, but are not presented here as a fabricated entity graph.",
@@ -660,52 +642,41 @@
     "entities.selectText": "The entity view aggregates related memories instead of relying on literal matching.",
     "entities.emptyTitle": "No related memories",
     "entities.emptyText": "Try the full name or another entity alias.",
-    "remember.title": "Distill Memory",
-    "remember.description": "An independent task Agent with no conversation history selects a Memory Space, checks duplicates, distills the candidate, and completes the write without filling the main conversation context.",
+    "remember.title": "Save to memory",
+    "remember.description": "A task Agent decides whether this is worth keeping, removes duplicates, distills it and writes it to the right Memory Space, outside this conversation.",
     "remember.readOnlyTitle": "Read-only mode",
     "remember.readOnlyText": "This deployment disables memory writes. Change and save the DSH Mnemon configuration to enable them.",
-    "remember.delegateTitle": "Send to independent task Agent",
-    "remember.noSession": "No live session",
-    "remember.ready": "Independent task Agent ready",
-    "remember.noTaskAgent": "Task Agent unavailable",
-    "remember.taskAgentReady": "Task Agent ready",
     "remember.candidate": "Candidate",
-    "remember.candidateAria": "Memory candidate",
-    "remember.placeholder": "Enter background, preferences, decisions, or insights worth retaining across tasks. The model decides whether they qualify.",
+    "remember.placeholder": "Background, preferences, decisions or conclusions worth keeping.",
     "remember.sessionHint": "No usable model route is available for an independent task Agent.",
     "remember.taskAgentHint": "The Host cannot currently create an isolated task Agent. Refresh status and try again.",
-    "remember.processing": "Independent task Agent is working…",
-    "remember.action": "Evaluate and distill",
-    "remember.advanced": "Advanced human constraints",
-    "remember.advancedHint": "Constrain the target Memory Space and metadata",
+    "remember.processing": "Task Agent working…",
+    "remember.action": "Send to task Agent",
+    "remember.advanced": "Advanced options",
+    "remember.advancedHint": "Choose the target space, category and importance",
     "remember.expand": "Expand",
     "remember.target": "Target Memory Space",
     "remember.asyncProviderHint": "This Memory Space waits for remote extraction to settle before returning a truthful write receipt.",
     "remember.entities": "Entities (comma-separated)",
     "remember.tags": "Tags (comma-separated)",
-    "remember.advancedText": "Advanced options constrain the independent task Agent; they do not bypass supervision or duplicate checks.",
-    "remember.saving": "Independent task Agent is writing…",
-    "remember.advancedAction": "Distill with constraints",
-    "remember.skipped": "The independent task Agent decided not to write",
-    "remember.completed": "The independent task Agent completed processing",
-    "remember.processed": "Independent task Agent processed: {action}",
-    "remember.dispatchFailed": "Dispatch failed: {error}",
-    "remember.saveFailed": "Save failed: {error}",
+    "remember.advancedText": "Constraints still go through the task Agent’s duplicate check and receipt.",
+    "remember.saving": "Task Agent working…",
+    "remember.advancedAction": "Send with constraints",
     "content.title": "Memory Content",
-    "content.description": "Inspect observable content through each provider’s real browse contract, with enumerable, query-only, and unavailable engines kept distinct.",
+    "content.description": "Browse what each Memory Space holds.",
     "content.sourcesTitle": "Provider content models",
     "content.count": "{count} memories",
     "content.filterAria": "Filter memory content",
     "content.filterPlaceholder": "Filter by content or exact ID…",
     "content.categoryAria": "Memory category",
     "content.apply": "Apply filters",
-    "content.notice": "Content calls each provider’s read-only browse contract directly; query-only engines run only after you enter a query.",
+    "content.notice": "Query-only Providers show content once you enter a query.",
     "content.queryRequiredTitle": "Query-only spaces are waiting",
     "content.queryRequiredText": "Enter a focused query to inspect providers such as ByteRover that do not expose a complete list.",
     "content.showing": "Showing {visible} / {total}",
     "content.showMore": "Show {count} more",
     "content.emptyTitle": "No matching memories",
-    "content.emptyText": "Clear the filters or distill the first durable memory.",
+    "content.emptyText": "Clear the filters or save a first memory.",
     "nav.spaces": "Memory Spaces",
     "overview.editSpace": "Edit",
     "overview.editSpaceAria": "Edit {name}",
@@ -715,6 +686,9 @@
     "overview.deleteSpaceAria": "Delete {name}",
     "overview.disconnectSpace": "Disconnect",
     "overview.disconnectSpaceAria": "Disconnect {name}",
-    "overview.deletingSpace": "Deleting…"
+    "overview.deletingSpace": "Deleting…",
+    "common.score": "Score {value}",
+    "overview.providerEnableHint": "Turn on more Providers on Memory Spaces’ page under Plugins → dsh-mnemon.",
+    "search.citations": "Cites"
   }
 }