dsh-mnemon 0.5.24 → 0.5.25

package/README.md

@@ -34,7 +34,7 @@ An Agent that starts every session from scratch keeps asking what it was already
 
 - **The right memory for each turn.** Preferences and working facts stay in context. Project documents and long-term evidence are searched only when a question needs them.
 - **You can see what a turn used.** Under each reply, the turn memory bar lists the documents and memories the turn read and wrote, and one click opens each in the Memory System. The Memory System shows everything that is stored and lets you edit it.
-- **Save to memory in one click.** When a conversation turns up a fact worth keeping, the brain mark under the reply hands it to a task Agent, which removes duplicates, distils it and writes it to the right Memory Space; the receipt says where it went.
+- **Save to memory in one click.** When a conversation turns up a fact worth keeping, the brain mark under the reply hands it to a task Agent, which removes duplicates, distils it and writes it to the right Memory Space, or saves it where you choose: working memory, your profile or a Memory Space. The receipt says where it went.
 - **Compose it on the Plugins page.** Choose a main strategy and optional enhancements, and switch them without moving any data. Every component has its own page for its settings.
 - **Keep data where you want it.** Local by default with Mnemon Native, or one of eight third-party Providers. Storage can be global, per workspace or centralized, with ZIP backup.
 - **Extend it.** Sources and Strategies are ordinary DSH plugins built on public SDKs. An installed component gets the same pages and switches as the shipped ones.

package/README.zh-CN.md

@@ -35,7 +35,7 @@
 
 - **每一轮都拿到合适的记忆。** 偏好和工作中的事实常驻上下文；项目档案与长期证据只在问题需要时才检索。
 - **看得见这一轮用了什么。** 每条回复下方的回合记忆栏列出这一轮读到和写入的档案与记忆，点一下就在记忆系统中打开它；记忆系统展示全部已保存的内容，并可直接编辑。
-- **一键存入记忆。** 对话里出现值得保留的事实，点击回复下的脑形图标，由任务 Agent 去重、提炼并写入合适的记忆空间，回执写明存到了哪里。
+- **一键存入记忆。** 对话里出现值得保留的事实，点击回复下的脑形图标，由任务 Agent 去重、提炼并写入合适的记忆空间，也可以直接存到你选择的位置：工作记忆、用户画像或某个记忆空间。回执写明存到了哪里。
 - **在插件页组合。** 选择一个主策略和若干可选增强，切换时无需迁移任何数据；每个组件都有自己的设置页。
 - **数据放在你想放的地方。** 默认由 Mnemon Native 在本地保存，也可以接入八种第三方 Provider；存储范围可选全局、按工作区或集中存储，并支持 ZIP 备份。
 - **可以扩展。** Source 与 Strategy 都是基于公开 SDK 的普通 DSH 插件；安装的组件与随附组件拥有同样的页面和开关。

package/lib/bundle.js

@@ -1,4 +1,4 @@
-import { t as prepareStarterResolution } from "./starter-resolution-DFLhgaoL.js";
+import { t as prepareStarterResolution } from "./starter-resolution-UcTGyjgm.js";
 //#region src/bundle.ts
 const groupKey = Symbol.for("cordis.group");
 const init = Symbol.for("cordis.init");

package/lib/client.js

@@ -739,6 +739,7 @@ window.__ModuleLoader__.load({
 			"runtime.result.remove": "已从{target}移除 · 当前 {count} 条",
 			"runtime.result.maintenance": "容量整理完成：已先归档到记忆空间 {spaces}，再更新{target} · 当前 {count} 条",
 			"runtime.result.localCompaction": "本地画像整理完成：未写入记忆空间，已更新{target} · 当前 {count} 条",
+			"runtime.result.localArchive": "容量整理完成：没有可写的记忆空间，已先把 {archived} 条移入本地归档，再更新{target} · 当前 {count} 条",
 			"runtime.readOnly": "当前为只读模式；运行时记忆仍会进入上下文，但不能在此修改。",
 			"runtime.footnote": "memories.json 是唯一事实源；两个 Markdown 文件由控制层生成，不应直接编辑。"
 		};
@@ -785,6 +786,7 @@ window.__ModuleLoader__.load({
 			"runtime.result.remove": "Removed from {target} · {count} entries",
 			"runtime.result.maintenance": "Capacity maintenance complete: archived to {spaces}, then updated {target} · {count} entries",
 			"runtime.result.localCompaction": "Local profile compaction complete: no Memory Space write; updated {target} · {count} entries",
+			"runtime.result.localArchive": "Capacity maintenance complete: with no Memory Space to write to, moved {archived} entries to the local archive, then updated {target} · {count} entries",
 			"runtime.readOnly": "Read only here: runtime memory still enters context but cannot be changed on this page.",
 			"runtime.footnote": "memories.json is the only source of truth. The control plane generates both Markdown files; do not edit them directly."
 		};
@@ -824,6 +826,7 @@ window.__ModuleLoader__.load({
 			"documents.updated": "已保存新的档案修订。",
 			"documents.updatedAfterArchive": "已先迁移 {count} 份旧档案，再保存修订。",
 			"documents.archived": "已建立 Mnemon 冷索引并归档；关联记忆空间：{spaces}",
+			"documents.archivedLocally": "已归档到本地：原文移入归档目录，没有建立 Mnemon 冷索引。",
 			"documents.list": "项目档案列表",
 			"documents.activeList": "活跃目录",
 			"documents.archiveList": "归档目录",
@@ -843,11 +846,12 @@ window.__ModuleLoader__.load({
 			"documents.hash": "内容哈希",
 			"documents.size": "文件大小",
 			"documents.archiveReceipt": "Mnemon 冷索引回执",
+			"documents.archiveNote": "归档说明",
 			"documents.archiveTitle": "迁入归档",
-			"documents.archiveDescription": "独立任务 Agent 先拟定摘要和目标空间；Host 校验后写入冷索引，再移动原文。需要已启用且支持精确写入与删除的记忆空间。",
+			"documents.archiveDescription": "独立任务 Agent 先拟定摘要和目标空间；Host 校验后写入冷索引，再移动原文。没有已启用且支持精确写入与删除的记忆空间时，原文直接移入本地归档，不建立索引。",
 			"documents.archive": "归档",
-			"documents.archiveConfirm": "确认建立 Mnemon 索引并迁移这份档案？",
-			"documents.archiving": "索引并迁移中…",
+			"documents.archiveConfirm": "确认归档这份档案？",
+			"documents.archiving": "归档中…",
 			"documents.archiveNow": "确认归档",
 			"documents.footnote": "`.mnemon/documents/index.json` 是控制面事实源；active 总量固定不超过 10 MB，archived 不计入上限，项目源文件不会被修改。"
 		};
@@ -885,6 +889,7 @@ window.__ModuleLoader__.load({
 			"documents.updated": "New document revision saved.",
 			"documents.updatedAfterArchive": "Archived {count} older document(s), then saved the revision.",
 			"documents.archived": "Mnemon cold index created and document archived; Memory Spaces: {spaces}",
+			"documents.archivedLocally": "Archived locally: the original moved to the archive, without a Mnemon cold index.",
 			"documents.list": "Project document list",
 			"documents.activeList": "Active directory",
 			"documents.archiveList": "Archive directory",
@@ -904,11 +909,12 @@ window.__ModuleLoader__.load({
 			"documents.hash": "Content hash",
 			"documents.size": "File size",
 			"documents.archiveReceipt": "Mnemon cold-index receipt",
+			"documents.archiveNote": "Archive note",
 			"documents.archiveTitle": "Move to archive",
-			"documents.archiveDescription": "An independent task Agent proposes a summary and destination. The Host validates and writes the cold index before moving the original. An active Memory Space with exact writes and safe deletion is required.",
+			"documents.archiveDescription": "An independent task Agent proposes a summary and destination. The Host validates and writes the cold index before moving the original. Without an active Memory Space that has exact writes and safe deletion, the original moves to the local archive without an index.",
 			"documents.archive": "Archive",
-			"documents.archiveConfirm": "Create the Mnemon index and archive this document?",
-			"documents.archiving": "Indexing and moving…",
+			"documents.archiveConfirm": "Archive this document?",
+			"documents.archiving": "Archiving…",
 			"documents.archiveNow": "Confirm archive",
 			"documents.footnote": "`.mnemon/documents/index.json` is the control-plane source of truth. active stays at or below 10 MB, archived is excluded, and project source files are never modified."
 		};
@@ -1739,6 +1745,7 @@ window.__ModuleLoader__.load({
 			"receipt.unfinished": "未完成",
 			"receipt.failed": "失败",
 			"receipt.view": "在记忆空间中查看",
+			"receipt.viewRuntime": "在运行时记忆中查看",
 			"taskAgent.ready": "任务 Agent 就绪",
 			"taskAgent.unavailable": "任务 Agent 不可用",
 			"saveAction.button": "存入记忆",
@@ -1753,6 +1760,31 @@ window.__ModuleLoader__.load({
 			"saveAction.submitting": "任务 Agent 处理中…",
 			"saveAction.readOnly": "当前部署为只读模式，无法写入记忆。",
 			"saveAction.close": "关闭",
+			"saveAction.hintDirect": "文本直接写入所选位置，不经过任务 Agent。",
+			"saveAction.to": "保存到",
+			"saveAction.to.agent": "由 Agent 决定",
+			"saveAction.to.agentDetail": "任务 Agent 判断是否值得保存，并选择记忆空间",
+			"saveAction.to.memory": "工作记忆（MEMORY.md）",
+			"saveAction.to.user": "用户画像（USER.md）",
+			"saveAction.to.space": "记忆空间 · {provider}",
+			"saveAction.save": "保存",
+			"saveAction.saving": "保存中…",
+			"saveAction.saved.runtime": "已存入{target} · 当前 {count} 条",
+			"saveAction.saved.runtimeMaintained": "已整理容量并存入{target} · 当前 {count} 条",
+			"saveAction.saved.space": "已存入记忆空间“{space}”",
+			"saveAction.saved.spacePending": "已提交到记忆空间“{space}”，由 Provider 稍后确认",
+			"saveAction.saved.spaceOther": "记忆空间“{space}”返回：{action}",
+			"saveAction.saved.duplicate": "内容已存在，没有重复写入。",
+			"saveAction.unavailable": "这个位置当前不可写。",
+			"saveAction.place.delimiter": "{target}的条目不能包含 §；删去后即可保存。",
+			"saveAction.place.tooLong": "这段文本约 {size}，超过{target}单条上限 {limit}；请删减。",
+			"saveAction.place.orAgent": "也可以交给 Agent 决定。",
+			"saveAction.place.full": "{target}已用 {used} / {limit}。保存前需要先整理容量：已有条目只保留约 {keep}，其余移出工作记忆。",
+			"saveAction.place.fullAll": "{target}已用 {used} / {limit}。保存前需要先整理容量：已有条目将全部移出工作记忆。",
+			"saveAction.place.userCondense": "用户画像已用 {used} / {limit}。保存前，任务 Agent 会把已有内容压缩到约 {keep} 以内，不留存档。",
+			"saveAction.place.userTooLong": "这段文本约 {size}，整理后的用户画像最多只能放下 {max}；请删减。",
+			"saveAction.place.userFull": "用户画像已满，整理它需要任务 Agent；请先在运行时记忆中删减条目，或换一个位置。",
+			"saveAction.noPlace": "现在没有可以写入的位置。",
 			"readSources.all": "全部 Provider",
 			"readSources.mode.search": "原生检索",
 			"readSources.mode.graph": "真实关系图",
@@ -2212,7 +2244,7 @@ window.__ModuleLoader__.load({
 			"config.interactionTurnBar": "回合记忆栏",
 			"config.interactionTurnBarHint": "每轮回复下方显示本轮的召回与写入",
 			"config.interactionSaveAction": "存入记忆按钮",
-			"config.interactionSaveActionHint": "在回复旁手动存入，确认后写入记忆空间",
+			"config.interactionSaveActionHint": "在回复旁手动存入，确认后写入你选择的位置",
 			"config.packTitle": "备份与迁移",
 			"config.packUnavailable": "当前 DSH 主机不支持 Mnemon ZIP 备份通道。",
 			"config.packExporting": "导出中…",
@@ -2335,6 +2367,7 @@ window.__ModuleLoader__.load({
 			"receipt.unfinished": "Not finished",
 			"receipt.failed": "Failed",
 			"receipt.view": "View in Memory Spaces",
+			"receipt.viewRuntime": "View in Runtime Memory",
 			"taskAgent.ready": "Task Agent ready",
 			"taskAgent.unavailable": "Task Agent unavailable",
 			"saveAction.button": "Save to memory",
@@ -2349,6 +2382,31 @@ window.__ModuleLoader__.load({
 			"saveAction.submitting": "Task Agent working…",
 			"saveAction.readOnly": "This deployment is read only; memory writes are disabled.",
 			"saveAction.close": "Close",
+			"saveAction.hintDirect": "The text goes straight to the chosen place, without a task Agent.",
+			"saveAction.to": "Save to",
+			"saveAction.to.agent": "Let the Agent decide",
+			"saveAction.to.agentDetail": "A task Agent decides whether to keep it and picks a Memory Space",
+			"saveAction.to.memory": "Working memory (MEMORY.md)",
+			"saveAction.to.user": "User profile (USER.md)",
+			"saveAction.to.space": "Memory Space · {provider}",
+			"saveAction.save": "Save",
+			"saveAction.saving": "Saving…",
+			"saveAction.saved.runtime": "Saved to {target} · {count} entries",
+			"saveAction.saved.runtimeMaintained": "Made room and saved to {target} · {count} entries",
+			"saveAction.saved.space": "Saved to the Memory Space {space}",
+			"saveAction.saved.spacePending": "Submitted to the Memory Space {space}; the Provider confirms it later",
+			"saveAction.saved.spaceOther": "The Memory Space {space} answered: {action}",
+			"saveAction.saved.duplicate": "Already saved; nothing was written twice.",
+			"saveAction.unavailable": "This place cannot take writes now.",
+			"saveAction.place.delimiter": "Entries in {target} cannot contain §; remove it to save.",
+			"saveAction.place.tooLong": "This text is about {size}, more than one entry in {target} holds ({limit}); shorten it.",
+			"saveAction.place.orAgent": " Or let the Agent decide.",
+			"saveAction.place.full": "{target} holds {used} of {limit}. Saving first makes room: about {keep} of the existing entries stay, and the rest move out of working memory.",
+			"saveAction.place.fullAll": "{target} holds {used} of {limit}. Saving first makes room: every existing entry moves out of working memory.",
+			"saveAction.place.userCondense": "The user profile holds {used} of {limit}. Before saving, a task Agent condenses it to about {keep}, keeping no archive.",
+			"saveAction.place.userTooLong": "This text is about {size}, more than the user profile can take after making room ({max}); shorten it.",
+			"saveAction.place.userFull": "The user profile is full, and making room in it needs a task Agent; remove entries in Runtime Memory first, or choose another place.",
+			"saveAction.noPlace": "No place can take this text now.",
 			"readSources.all": "All providers",
 			"readSources.mode.search": "Native search",
 			"readSources.mode.graph": "True relation graph",
@@ -2808,7 +2866,7 @@ window.__ModuleLoader__.load({
 			"config.interactionTurnBar": "Turn memory bar",
 			"config.interactionTurnBarHint": "Shows each turn's recall and writes below the reply",
 			"config.interactionSaveAction": "Save to memory action",
-			"config.interactionSaveActionHint": "Save a reply by hand; it goes into a Memory Space after you confirm",
+			"config.interactionSaveActionHint": "Save a reply by hand; it goes where you choose after you confirm",
 			"config.packTitle": "Backup and migration",
 			"config.packUnavailable": "This DSH host does not provide the Mnemon ZIP backup channel.",
 			"config.packExporting": "Exporting…",
@@ -6804,7 +6862,7 @@ window.__ModuleLoader__.load({
 						size: "sm",
 						className: PageControls_module_css_default.receiptAction,
 						onClick: props.onView,
-						children: t("receipt.view")
+						children: props.viewLabel ?? t("receipt.view")
 					})
 				]
 			});
@@ -8726,7 +8784,7 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region \0dsh-mnemon-css:/home/runner/work/dsh-mnemon/dsh-mnemon/src/client/MnemonSaveAction.module.css.mjs
-		const css$1 = ".ypSjoa_wrap{display:inline-flex;position:relative}.ypSjoa_button{cursor:pointer;width:28px;height:28px;color:var(--dsw-alias-label-tertiary);background:0 0;border:none;border-radius:28px;justify-content:center;align-items:center;padding:6px;display:inline-flex}.ypSjoa_button:hover,.ypSjoa_button[aria-expanded=true]{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary)}.ypSjoa_button:focus-visible{outline:var(--dsw-focus-ring-width,2px) solid var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary));outline-offset:2px}.ypSjoa_icon{flex:none;width:16px;height:16px;display:inline-flex}.ypSjoa_modal{width:min(640px, calc(100vw - max(12px, env(safe-area-inset-left,0px)) - max(12px, env(safe-area-inset-right,0px))));max-height:calc(100vh - 24px)}.ypSjoa_modalContent{overscroll-behavior:contain;-webkit-overflow-scrolling:touch;min-height:0;overflow-y:auto}.ypSjoa_modalAction{min-width:96px}.ypSjoa_status{color:var(--dsw-alias-label-tertiary);margin:0;font-size:13px;line-height:20px}.ypSjoa_readOnly{border-radius:var(--dsw-radius-md);background:var(--dsw-alias-state-warn-tertiary);color:var(--dsw-alias-state-warn-label);margin-bottom:12px;padding:8px 12px;font-size:12px;line-height:18px}.ypSjoa_candidate{display:block}.ypSjoa_candidateHeading{justify-content:space-between;align-items:center;gap:8px;min-width:0;margin-bottom:6px;display:flex}.ypSjoa_candidateHeading>label{color:var(--dsw-alias-label-primary);font-size:13px;font-weight:500;line-height:20px}.ypSjoa_candidate textarea{box-sizing:border-box;border:.5px solid var(--dsw-alias-border-l4);border-radius:var(--dsw-radius-md);resize:vertical;background:var(--dsw-alias-bg-layer-3);width:100%;min-height:260px;max-height:50vh;color:var(--dsw-alias-label-primary);font:14px/22px var(--dsw-font-family);padding:10px 12px;display:block}.ypSjoa_candidate textarea:focus-visible{border-color:var(--dsw-alias-state-business-primary);outline:none}.ypSjoa_truncated{color:var(--dsw-alias-label-tertiary);margin-top:6px;font-size:12px;line-height:18px;display:block}@media (width<=640px),(height<=560px){.ypSjoa_modal{width:min(100%, calc(100vw - max(8px, env(safe-area-inset-left,0px)) - max(8px, env(safe-area-inset-right,0px))));max-height:calc(100vh - 16px)}.ypSjoa_modal .ypSjoa_modalAction{min-width:0;min-height:44px}.ypSjoa_candidate textarea{min-height:clamp(140px,32vh,220px);max-height:42vh}}@media (pointer:coarse) and (width<=640px),(pointer:coarse) and (height<=560px){.ypSjoa_candidate textarea{font-size:16px}}@supports (height:100dvh){.ypSjoa_modal{max-height:calc(100dvh - 24px)}@media (width<=640px),(height<=560px){.ypSjoa_modal{max-height:calc(100dvh - 16px)}.ypSjoa_candidate textarea{min-height:clamp(140px,32dvh,220px);max-height:42dvh}}}";
+		const css$1 = ".ypSjoa_wrap{display:inline-flex;position:relative}.ypSjoa_button{cursor:pointer;width:28px;height:28px;color:var(--dsw-alias-label-tertiary);background:0 0;border:none;border-radius:28px;justify-content:center;align-items:center;padding:6px;display:inline-flex}.ypSjoa_button:hover,.ypSjoa_button[aria-expanded=true]{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary)}.ypSjoa_button:focus-visible{outline:var(--dsw-focus-ring-width,2px) solid var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary));outline-offset:2px}.ypSjoa_icon{flex:none;width:16px;height:16px;display:inline-flex}.ypSjoa_modal{width:min(640px, calc(100vw - max(12px, env(safe-area-inset-left,0px)) - max(12px, env(safe-area-inset-right,0px))));max-height:calc(100vh - 24px)}.ypSjoa_modalContent{overscroll-behavior:contain;-webkit-overflow-scrolling:touch;min-height:0;overflow-y:auto}.ypSjoa_modalAction{min-width:96px}.ypSjoa_status{color:var(--dsw-alias-label-tertiary);margin:0;font-size:13px;line-height:20px}.ypSjoa_readOnly{border-radius:var(--dsw-radius-md);background:var(--dsw-alias-state-warn-tertiary);color:var(--dsw-alias-state-warn-label);margin-bottom:12px;padding:8px 12px;font-size:12px;line-height:18px}.ypSjoa_candidate{display:block}.ypSjoa_candidateHeading{justify-content:space-between;align-items:center;gap:8px;min-width:0;margin-bottom:6px;display:flex}.ypSjoa_candidateHeading>label{color:var(--dsw-alias-label-primary);font-size:13px;font-weight:500;line-height:20px}.ypSjoa_candidate textarea{box-sizing:border-box;border:.5px solid var(--dsw-alias-border-l4);border-radius:var(--dsw-radius-md);resize:vertical;background:var(--dsw-alias-bg-layer-3);width:100%;min-height:260px;max-height:50vh;color:var(--dsw-alias-label-primary);font:14px/22px var(--dsw-font-family);padding:10px 12px;display:block}.ypSjoa_candidate textarea:focus-visible{border-color:var(--dsw-alias-state-business-primary);outline:none}.ypSjoa_destination{margin-top:12px}.ypSjoa_truncated,.ypSjoa_placeNote{color:var(--dsw-alias-label-tertiary);margin-top:6px;font-size:12px;line-height:18px;display:block}.ypSjoa_placeNote[data-tone=blocked]{color:var(--dsw-alias-state-warn-label)}@media (width<=640px),(height<=560px){.ypSjoa_modal{width:min(100%, calc(100vw - max(8px, env(safe-area-inset-left,0px)) - max(8px, env(safe-area-inset-right,0px))));max-height:calc(100vh - 16px)}.ypSjoa_modal .ypSjoa_modalAction{min-width:0;min-height:44px}.ypSjoa_candidate textarea{min-height:clamp(140px,32vh,220px);max-height:42vh}}@media (pointer:coarse) and (width<=640px),(pointer:coarse) and (height<=560px){.ypSjoa_candidate textarea{font-size:16px}}@supports (height:100dvh){.ypSjoa_modal{max-height:calc(100dvh - 24px)}@media (width<=640px),(height<=560px){.ypSjoa_modal{max-height:calc(100dvh - 16px)}.ypSjoa_candidate textarea{min-height:clamp(140px,32dvh,220px);max-height:42dvh}}}";
 		const tagId$1 = "dsh-mnemon/src/client/MnemonSaveAction.module.css";
 		if (typeof document !== "undefined") {
 			let tag = document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$1) + "]");
@@ -8741,10 +8799,12 @@ window.__ModuleLoader__.load({
 			"button": "ypSjoa_button",
 			"candidate": "ypSjoa_candidate",
 			"candidateHeading": "ypSjoa_candidateHeading",
+			"destination": "ypSjoa_destination",
 			"icon": "ypSjoa_icon",
 			"modal": "ypSjoa_modal",
 			"modalAction": "ypSjoa_modalAction",
 			"modalContent": "ypSjoa_modalContent",
+			"placeNote": "ypSjoa_placeNote",
 			"readOnly": "ypSjoa_readOnly",
 			"status": "ypSjoa_status",
 			"truncated": "ypSjoa_truncated",
@@ -8753,10 +8813,167 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/MnemonSaveAction.tsx
 		const PREVIEW_LIMIT = 8e3;
+		/** One working-memory entry as Runtime Memory stores it: one line of at most 8 KiB, without the § delimiter. */
+		const RUNTIME_ENTRY_BYTES = 8192;
+		const RUNTIME_PLACES = {
+			"runtime:memory": "saveAction.to.memory",
+			"runtime:user": "saveAction.to.user"
+		};
+		function isRuntimePlace(destination) {
+			return destination === "runtime:memory" || destination === "runtime:user";
+		}
+		/**
+		* The places a candidate can go. A layer takes it while it is on, its Source
+		* runs and its writes are not switched off. What the status does not say
+		* counts as available, so a partial status never hides the task Agent.
+		*/
+		function saveDestinations(status, taskAgent, t) {
+			const system = status?.memorySystem;
+			const takes = (sourceTypeId) => {
+				const layer = system?.configuration.layers[sourceTypeId];
+				return layer?.enabled !== false && layer?.participation?.write !== "off" && (system?.sources === void 0 || system.sources.some((source) => source.sourceTypeId === sourceTypeId));
+			};
+			const runtimeOn = takes("runtime");
+			const spacesOn = takes("memory-spaces");
+			const spaces = spacesOn ? (status?.memoryBodies ?? []).filter((body) => body.active !== false && body.providerEnabled !== false && body.provider.capabilities.remember && ((body.provider.typeId ?? body.provider.id) !== "mnemon-native" || status?.commandFound !== false)) : [];
+			const providerReady = spaces.length > 0 || status?.commandFound !== false || (status?.providerServices ?? []).some((provider) => provider.enabled && provider.configured);
+			return [
+				{
+					value: "agent",
+					label: t("saveAction.to.agent"),
+					detail: t("saveAction.to.agentDetail"),
+					disabled: taskAgent === false || !spacesOn || !providerReady
+				},
+				...runtimeOn ? Object.keys(RUNTIME_PLACES).map((value) => ({
+					value,
+					label: t(RUNTIME_PLACES[value])
+				})) : [],
+				...spaces.map((body) => ({
+					value: `space:${body.id}`,
+					label: body.name,
+					detail: t("saveAction.to.space", { provider: body.provider.label })
+				}))
+			];
+		}
+		/** The default instance of a Source type, as the workbench picks it, else the first. */
+		function placeSource(catalog, sourceTypeId) {
+			const sources = catalog.sources.filter((source) => source.sourceTypeId === sourceTypeId);
+			return sources.find((source) => isDefaultSourceInstance(source.sourceInstanceKey, sourceTypeId)) ?? sources[0];
+		}
+		/** Write the text to the place the user chose, through that Source's own operation, with a fresh revision. */
+		async function saveDirectly(client, destination, place, content, t) {
+			const source = placeSource(await client.sourceManagementCatalog(), isRuntimePlace(destination) ? "runtime" : "memory-spaces");
+			if (source === void 0) throw new Error(t("saveAction.unavailable"));
+			if (isRuntimePlace(destination)) {
+				const input = {
+					action: "add",
+					target: destination === "runtime:user" ? "user" : "memory",
+					content
+				};
+				const result = (source.assistance?.includes("mutate") === true ? await client.assistSource(source.sourceInstanceKey, "mutate", input, source.revision, true) : await client.mutateSourceManagement(source.sourceInstanceKey, "mutate", input, source.revision, true)).value;
+				if (result.message?.startsWith("Entry already exists") === true) return {
+					action: "skipped",
+					note: { key: "saveAction.saved.duplicate" }
+				};
+				return {
+					action: "added",
+					note: {
+						key: result.maintenance === void 0 ? "saveAction.saved.runtime" : "saveAction.saved.runtimeMaintained",
+						params: { count: result.entryCount },
+						place: RUNTIME_PLACES[destination]
+					}
+				};
+			}
+			const result = (await client.mutateSourceManagement(source.sourceInstanceKey, "remember", {
+				content,
+				memoryBodyId: destination.slice(6),
+				source: "user"
+			}, source.revision, true)).value;
+			const answered = typeof result.action === "string" ? result.action : "stored";
+			const action = answered === "queued" ? "accepted" : answered;
+			const outcome = writeOutcome(action);
+			return {
+				action,
+				note: {
+					key: outcome === "skipped" ? "saveAction.saved.duplicate" : outcome === "pending" ? "saveAction.saved.spacePending" : outcome === "written" || outcome === "updated" ? "saveAction.saved.space" : "saveAction.saved.spaceOther",
+					params: {
+						space: place,
+						action: answered
+					}
+				}
+			};
+		}
+		/**
+		* What a working-memory place says about this text before it is saved, and
+		* whether it can take it at all, by the Runtime Source's own rules: one line of
+		* at most 8 KiB and never more than its file, without the § delimiter. A full
+		* file keeps its entries within 70% of its limit, less the new one.
+		*/
+		function runtimePlaceNote(destination, content, usage, taskAgent, agentOpen, t) {
+			if (!isRuntimePlace(destination) || content === "") return void 0;
+			const user = destination === "runtime:user";
+			const target = t(RUNTIME_PLACES[destination]);
+			const entry = content.replace(/\s+/gu, " ");
+			if (entry.includes("§")) return {
+				text: t("saveAction.place.delimiter", { target }),
+				blocked: true
+			};
+			const bytes = new TextEncoder().encode(entry).length;
+			const room = usage?.[user ? "user" : "memory"];
+			const cap = Math.min(RUNTIME_ENTRY_BYTES, room?.limit ?? RUNTIME_ENTRY_BYTES);
+			const orAgent = agentOpen ? t("saveAction.place.orAgent") : "";
+			if (bytes > cap) {
+				const exact = humanBytes(bytes) === humanBytes(cap);
+				return {
+					text: t("saveAction.place.tooLong", {
+						target,
+						size: exact ? `${bytes} B` : humanBytes(bytes),
+						limit: exact ? `${cap} B` : humanBytes(cap)
+					}) + orAgent,
+					blocked: true
+				};
+			}
+			if (room === void 0 || room.used + bytes + (room.used > 0 ? 4 : 0) <= room.limit) return void 0;
+			const kept = Math.floor(room.limit * .7) - 4;
+			const keep = Math.max(0, kept - bytes);
+			const used = humanBytes(room.used);
+			const limit = humanBytes(room.limit);
+			if (user) {
+				if (taskAgent === false) return {
+					text: t("saveAction.place.userFull"),
+					blocked: true
+				};
+				if (keep === 0) return {
+					text: t("saveAction.place.userTooLong", {
+						size: humanBytes(bytes),
+						max: humanBytes(Math.max(0, kept))
+					}) + orAgent,
+					blocked: true
+				};
+				return {
+					text: t("saveAction.place.userCondense", {
+						used,
+						limit,
+						keep: humanBytes(keep)
+					}),
+					blocked: false
+				};
+			}
+			return {
+				text: t(keep === 0 ? "saveAction.place.fullAll" : "saveAction.place.full", {
+					target,
+					used,
+					limit,
+					keep: humanBytes(keep)
+				}),
+				blocked: false
+			};
+		}
 		/**
 		* Save-to-memory action on finalized assistant messages. A task Agent decides
-		* whether the (editable) reply is worth keeping and writes it; the dialog
-		* shows the same receipt as Save to memory on the Memory Spaces page.
+		* whether the (editable) reply is worth keeping and where it goes, or the user
+		* names the place and the text goes there through that place's own write. The
+		* dialog shows the same receipt as Save to memory on the Memory Spaces page.
 		*/
 		const MnemonSaveAction = (0, react.memo)(function MnemonSaveAction({ messageId, sessionId, connection, settingsScope, localeRuntime, t }) {
 			const subscribeLocale = (0, react.useCallback)((listener) => localeRuntime.subscribe(listener), [localeRuntime]);
@@ -8769,15 +8986,19 @@ window.__ModuleLoader__.load({
 			const [open, setOpen] = (0, react.useState)(false);
 			const [writeEnabled, setWriteEnabled] = (0, react.useState)(void 0);
 			const [taskAgent, setTaskAgent] = (0, react.useState)(void 0);
+			const [status, setStatus] = (0, react.useState)(void 0);
+			const [chosen, setChosen] = (0, react.useState)(void 0);
 			const [candidate, setCandidate] = (0, react.useState)(void 0);
 			const [truncated, setTruncated] = (0, react.useState)(false);
 			const [missing, setMissing] = (0, react.useState)(false);
 			const [submitting, setSubmitting] = (0, react.useState)(false);
 			const [outcome, setOutcome] = (0, react.useState)(null);
+			const [usage, setUsage] = (0, react.useState)(void 0);
 			const candidateId = (0, react.useId)();
 			const openRef = (0, react.useRef)(false);
 			const requestVersionRef = (0, react.useRef)(0);
-			const submitActiveRef = (0, react.useRef)(false);
+			const inFlightRef = (0, react.useRef)(void 0);
+			const unseenRef = (0, react.useRef)(void 0);
 			const setPanelOpen = (next) => {
 				requestVersionRef.current += 1;
 				openRef.current = next;
@@ -8787,33 +9008,45 @@ window.__ModuleLoader__.load({
 				if (!open) {
 					setWriteEnabled(void 0);
 					setTaskAgent(void 0);
+					setStatus(void 0);
+					setChosen(void 0);
 					setCandidate(void 0);
 					setTruncated(false);
 					setMissing(false);
-					setSubmitting(submitActiveRef.current);
+					setSubmitting(inFlightRef.current !== void 0);
 					setOutcome(null);
+					setUsage(void 0);
 					return;
 				}
 				const requestVersion = ++requestVersionRef.current;
 				let alive = true;
-				setSubmitting(submitActiveRef.current);
+				setSubmitting(inFlightRef.current !== void 0);
+				const unseen = unseenRef.current;
+				unseenRef.current = void 0;
+				const restored = unseen ?? inFlightRef.current;
+				if (restored !== void 0) setChosen(restored.destination);
+				if (unseen !== void 0) setOutcome(unseen);
 				const client = new MnemonClient(connection, sessionId);
 				client.status().then((status) => {
 					if (!alive || requestVersionRef.current !== requestVersion) return;
 					setWriteEnabled(status.writeEnabled && managementWritable);
 					setTaskAgent(status.lifecycle?.taskAgentAvailable);
+					setStatus(status);
 				}).catch(() => {
 					if (alive && requestVersionRef.current === requestVersion) setWriteEnabled(false);
 				});
 				client.assistantMessageText(messageId).then((result) => {
 					if (!alive || requestVersionRef.current !== requestVersion) return;
-					if (result === null || result.text === "") setMissing(true);
+					if (restored !== void 0) setCandidate(restored.content);
+					else if (result === null || result.text === "") setMissing(true);
 					else {
 						setTruncated(result.text.length > PREVIEW_LIMIT);
 						setCandidate(result.text.slice(0, PREVIEW_LIMIT));
 					}
 				}).catch(() => {
-					if (alive && requestVersionRef.current === requestVersion) setMissing(true);
+					if (!alive || requestVersionRef.current !== requestVersion) return;
+					if (restored !== void 0) setCandidate(restored.content);
+					else setMissing(true);
 				});
 				return () => {
 					alive = false;
@@ -8826,37 +9059,83 @@ window.__ModuleLoader__.load({
 				managementWritable
 			]);
 			const content = candidate?.trim() ?? "";
-			const answered = outcome !== null && outcome.content === content;
-			const canSubmit = content !== "" && !submitting && writeEnabled === true && taskAgent !== false && !answered;
+			const options = saveDestinations(status, taskAgent, t);
+			const usable = options.filter((option) => option.disabled !== true);
+			const destination = chosen ?? usable[0]?.value ?? "agent";
+			const selected = options.find((option) => option.value === destination);
+			const runtimeTarget = isRuntimePlace(destination) ? destination : void 0;
+			(0, react.useEffect)(() => {
+				if (!open || runtimeTarget === void 0 || usage !== void 0 || status === void 0) return;
+				const runtime = status.memorySystem === void 0 ? void 0 : placeSource(status.memorySystem, "runtime");
+				if (runtime === void 0) {
+					setUsage({});
+					return;
+				}
+				let alive = true;
+				new MnemonClient(connection, sessionId).readSourceManagement(runtime.sourceInstanceKey, "snapshot").then((result) => {
+					if (alive) setUsage(result.value?.targets ?? {});
+				}, () => {
+					if (alive) setUsage({});
+				});
+				return () => {
+					alive = false;
+				};
+			}, [
+				open,
+				runtimeTarget,
+				usage,
+				status,
+				connection,
+				sessionId
+			]);
+			const placeNote = runtimePlaceNote(destination, content, usage, taskAgent, options.some((option) => option.value === "agent" && option.disabled !== true), t);
+			const answered = outcome !== null && outcome.error === void 0 && outcome.content === content && outcome.destination === destination;
+			const placeReady = runtimeTarget === void 0 || usage !== void 0;
+			const canSubmit = content !== "" && !submitting && writeEnabled === true && selected !== void 0 && selected.disabled !== true && placeReady && placeNote?.blocked !== true && !answered;
 			const submit = () => {
-				if (!canSubmit || submitActiveRef.current) return;
+				if (!canSubmit || inFlightRef.current !== void 0) return;
 				const requestVersion = requestVersionRef.current;
-				submitActiveRef.current = true;
+				const target = destination;
+				inFlightRef.current = {
+					content,
+					destination: target
+				};
 				setSubmitting(true);
 				setOutcome(null);
-				new MnemonClient(connection, sessionId).supervise(content, messageId).then((result) => {
-					if (openRef.current && requestVersionRef.current === requestVersion) setOutcome({
-						content,
-						action: result.action,
-						summary: result.summary
-					});
-				}).catch((reason) => {
-					if (openRef.current && requestVersionRef.current === requestVersion) setOutcome({
-						content,
-						error: message(reason)
-					});
-				}).finally(() => {
-					submitActiveRef.current = false;
+				const client = new MnemonClient(connection, sessionId);
+				(target === "agent" ? client.supervise(content, messageId).then((result) => ({
+					action: result.action,
+					summary: result.summary
+				})) : saveDirectly(client, target, selected?.label ?? target, content, t)).then((result) => ({
+					content,
+					destination: target,
+					...result
+				}), (reason) => ({
+					content,
+					destination: target,
+					error: message(reason)
+				})).then((result) => {
+					inFlightRef.current = void 0;
+					if (openRef.current && (target !== "agent" || requestVersionRef.current === requestVersion)) setOutcome(result);
+					else if (!openRef.current && target !== "agent") unseenRef.current = result;
 					if (openRef.current) setSubmitting(false);
+					if (isRuntimePlace(target) && result.error === void 0) setUsage(void 0);
 				});
 			};
 			const viewMemory = () => {
+				const runtime = outcome !== null && isRuntimePlace(outcome.destination);
 				setPanelOpen(false);
 				dispatchMnemonAnchor({
-					page: "memory-spaces/content",
+					page: runtime ? "runtime/entries" : "memory-spaces/content",
+					...runtime ? { seed: outcome.content.replace(/\s+/gu, " ") } : {},
 					...sessionId === void 0 ? {} : { sessionId }
 				});
 			};
+			const direct = writeEnabled === true && destination !== "agent";
+			const receiptSummary = outcome?.note === void 0 ? outcome?.summary : t(outcome.note.key, {
+				...outcome.note.params,
+				...outcome.note.place === void 0 ? {} : { target: t(outcome.note.place) }
+			});
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: MnemonSaveAction_module_css_default.wrap,
 				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Tooltip, {
@@ -8880,7 +9159,7 @@ window.__ModuleLoader__.load({
 					onClose: () => setPanelOpen(false),
 					title: t("saveAction.title"),
 					closeLabel: t("saveAction.close"),
-					description: t("saveAction.hint"),
+					description: t(direct ? "saveAction.hintDirect" : "saveAction.hint"),
 					className: MnemonSaveAction_module_css_default.modal,
 					contentClassName: MnemonSaveAction_module_css_default.modalContent,
 					footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
@@ -8894,7 +9173,7 @@ window.__ModuleLoader__.load({
 						className: MnemonSaveAction_module_css_default.modalAction,
 						disabled: !canSubmit,
 						onClick: submit,
-						children: submitting ? t("saveAction.submitting") : t("saveAction.submit")
+						children: direct ? submitting ? t("saveAction.saving") : t("saveAction.save") : submitting ? t("saveAction.submitting") : t("saveAction.submit")
 					})] }),
 					children: [
 						writeEnabled === false && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
@@ -8919,8 +9198,8 @@ window.__ModuleLoader__.load({
 									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
 										htmlFor: candidateId,
 										children: t("saveAction.candidate")
-									}), writeEnabled === true && taskAgent !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TaskAgentTag, {
-										available: taskAgent,
+									}), writeEnabled === true && !direct && taskAgent !== void 0 && usable.length > 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TaskAgentTag, {
+										available: taskAgent && selected?.disabled !== true,
 										t
 									})]
 								}),
@@ -8934,15 +9213,34 @@ window.__ModuleLoader__.load({
 								truncated && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("small", {
 									className: MnemonSaveAction_module_css_default.truncated,
 									children: t("saveAction.truncated", { limit: PREVIEW_LIMIT })
+								}),
+								writeEnabled === true && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SelectField, {
+									className: MnemonSaveAction_module_css_default.destination,
+									label: t("saveAction.to"),
+									value: destination,
+									options,
+									disabled: submitting,
+									onChange: setChosen
+								}),
+								writeEnabled === true && placeNote !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("small", {
+									className: MnemonSaveAction_module_css_default.placeNote,
+									"data-tone": placeNote.blocked ? "blocked" : "caution",
+									children: placeNote.text
+								}),
+								writeEnabled === true && status !== void 0 && usable.length === 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("small", {
+									className: MnemonSaveAction_module_css_default.placeNote,
+									"data-tone": "blocked",
+									children: t("saveAction.noPlace")
 								})
 							]
 						}),
 						outcome !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(WriteReceipt, {
 							t,
 							action: outcome.action,
-							summary: outcome.summary,
+							summary: receiptSummary,
 							error: outcome.error,
-							onView: viewMemory
+							onView: viewMemory,
+							...isRuntimePlace(outcome.destination) ? { viewLabel: t("receipt.viewRuntime") } : {}
 						})
 					]
 				})]
@@ -12236,6 +12534,7 @@ window.__ModuleLoader__.load({
 				componentChanges: seats.components,
 				t: translate
 			});
+			const renderContributed = (packageName, owner) => renderComponentRegion(ctx, MNEMON_COMPONENT_SETTINGS_SLOT, packageName, owner);
 			ctx.slots.inject("plugins.bundle.config", () => ctx.slots.register({
 				name: "plugins.bundle.config",
 				key: MNEMON_PACKAGE_NAME,
@@ -12244,9 +12543,11 @@ window.__ModuleLoader__.load({
 					kind: "keyed",
 					scope: "root"
 				} },
-				inject: configurationServices
+				inject: () => ({
+					...configurationServices(),
+					renderContributed
+				})
 			}, MnemonSettingsHost));
-			const renderContributed = (packageName, owner) => renderComponentRegion(ctx, MNEMON_COMPONENT_SETTINGS_SLOT, packageName, owner);
 			for (const { rowId, packageName } of STARTER_COMPONENT_ROWS) ctx.slots.inject("plugins.row.config", () => ctx.slots.register({
 				name: "plugins.row.config",
 				key: `${MNEMON_PACKAGE_NAME}#${rowId}`,

package/lib/index.js

@@ -7,7 +7,7 @@ import z from "@deepseek-ai/schemastery";
 import { basename, delimiter, dirname, isAbsolute, join, normalize, resolve } from "node:path";
 import { resolveEmbedding, resolvePersistenceStrategy, resolveRecallQuality } from "dsh-mnemon-source-memory-spaces";
 import { createHash, randomUUID } from "node:crypto";
-import { accessSync, closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { strToU8, unzipSync, zipSync } from "fflate";
 import { DOCUMENTS_ACTIVE_LIMIT_BYTES, DOCUMENTS_VERSION } from "dsh-mnemon-source-documents/contracts";
@@ -862,6 +862,33 @@ function readCurrentRuntime(root, limits = RUNTIME_MEMORY_LIMITS) {
 	const path = join(root, "runtime", "memories.json");
 	return existsSync(path) ? parseRuntime(JSON.parse(readFileSync(path, "utf8")), limits) : emptyRuntime();
 }
+/**
+* A Pack carries no local archive: the one MEMORY.md wrote while no Memory Space
+* could take its entries holds their only copy, so an import keeps it (#336).
+* Its files and folders are carried; a link is neither carried nor followed.
+*/
+function keepRuntimeArchive(root, stagedRuntime) {
+	const copy = (from, to) => {
+		let stat;
+		try {
+			stat = lstatSync(from);
+		} catch {
+			return;
+		}
+		if (stat.isSymbolicLink()) return;
+		if (stat.isFile()) {
+			copyFileSync(from, to);
+			chmodSync(to, 384);
+		} else if (stat.isDirectory()) {
+			mkdirSync(to, {
+				recursive: true,
+				mode: 448
+			});
+			for (const name of readdirSync(from)) copy(join(from, name), join(to, name));
+		}
+	};
+	copy(join(root, "runtime", "archived"), join(stagedRuntime, "archived"));
+}
 function writeRuntime(directory, file) {
 	mkdirSync(directory, {
 		recursive: true,
@@ -1120,6 +1147,7 @@ function stageImport(root, pack, components, mode, runtimeLimits) {
 		if (components.includes("runtime")) {
 			const runtime = mode === "merge" ? mergeRuntime(root, pack, runtimeLimits) : parseRuntime(json$1(pack.files["payload/runtime/memories.json"], "payload/runtime/memories.json"), runtimeLimits);
 			writeRuntime(join(staging, "runtime"), runtime);
+			keepRuntimeArchive(root, join(staging, "runtime"));
 		}
 		if (components.includes("documents")) {
 			const documents = mode === "merge" ? mergeDocuments(root, pack) : archiveDocuments(pack);
@@ -3437,6 +3465,14 @@ function pendingMutationContext(plan) {
 		...plan.excluded === void 0 ? [] : [`- Matched committed entry: excluded by the host because it will be ${plan.action === "replace" ? "replaced" : "removed"}`]
 	].join("\n");
 }
+/**
+* A space that can take a MEMORY.md archive or a Document's index: active, its
+* Provider enabled and ready, with exact writes and safe forget. A Mnemon Native
+* space stays listed, and active, while its CLI is missing; it takes no writes then.
+*/
+function archivableSpace(directory, body) {
+	return body.active && body.providerEnabled !== false && body.provider.capabilities.remember === true && body.provider.capabilities.writeMode === "exact" && body.provider.capabilities.forget === true && directory.providers?.find((provider) => provider.id === body.provider.id)?.serviceConfigured !== false;
+}
 function compactedBudget(plan) {
 	const pendingBytes = plan.pending === void 0 ? 0 : Buffer.byteLength(plan.pending.content, "utf8");
 	const separatorBytes = plan.pending === void 0 || plan.entries.length === 0 ? 0 : Buffer.byteLength(RUNTIME_ENTRY_DELIMITER, "utf8");
@@ -3595,6 +3631,22 @@ function destinationFromCommittedMutation(result, memoryBodyId, content) {
 		digest
 	};
 }
+/**
+* The memory a skipped write names as already holding exactly this text, when
+* its receipt carries that memory's id and stored text. Anything less proves
+* nothing, and the caller verifies by search instead.
+*/
+function skippedExactDestination(result, memoryBodyId, content) {
+	const value = optionalObject(result);
+	const id = typeof value?.id === "string" ? value.id.trim() : "";
+	if (id === "" || value?.content !== content) return void 0;
+	if (value.memoryBodyId !== void 0 && value.memoryBodyId !== memoryBodyId) return void 0;
+	return {
+		layerId: "memory-spaces",
+		reference: `memory-space:${encodeURIComponent(memoryBodyId)}/item:${encodeURIComponent(id)}`,
+		digest: sha256(content)
+	};
+}
 function mutationStates(result) {
 	const value = optionalObject(result);
 	return [value?.action, value?.status].filter((entry) => typeof entry === "string").map((entry) => entry.trim().toLocaleLowerCase());
@@ -3892,11 +3944,13 @@ var MnemonSubagentCoordinator = class {
 				commit: () => runtime.mutate("mutate", request, signal),
 				memorySpaces: async () => {
 					if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
-					assertParticipation(graph.config, "memory-spaces", "write", "automatic");
+					if (!allowsParticipation(graph.config, "memory-spaces", "write", "automatic") || !lease.generation.sourceInstances().some((source) => source.sourceTypeId === "memory-spaces")) return void 0;
 					const source = graph.source("memory-spaces", scope).forGeneration(lease.generation);
+					const { sourceInstanceKey } = await source.identity();
 					return {
 						source,
-						cleanup: source
+						cleanup: source,
+						elsewhere: await this.archivableElsewhere(graph, scope, lease.generation, sourceInstanceKey, signal)
 					};
 				},
 				model: (...args) => this.runtimeModel(scope, parent, signal, ...args)
@@ -3946,7 +4000,7 @@ var MnemonSubagentCoordinator = class {
 				},
 				memorySpaces: async () => {
 					if (!authorize()) throw new Error("Runtime capacity maintenance is no longer authorized");
-					return this.runtimeArchiveSource(graph, turn.scope, turn.view, lease.generation, turn);
+					return this.runtimeArchiveSource(graph, turn.scope, turn.view, lease.generation, turn, signal);
 				},
 				model: (...args) => this.runtimeModel(turn.scope, parent, signal, ...args)
 			}, input, signal);
@@ -3992,7 +4046,7 @@ var MnemonSubagentCoordinator = class {
 						scenario: "management.runtime-capacity",
 						budget: DEFAULT_MEMORY_VIEW_BUDGET
 					}, signal);
-					return this.runtimeArchiveSource(graph, request.scope, view, generation);
+					return this.runtimeArchiveSource(graph, request.scope, view, generation, void 0, signal);
 				},
 				model: (...args) => this.runtimeModel(request.scope, void 0, signal, ...args)
 			}, request.input, signal);
@@ -4006,11 +4060,14 @@ var MnemonSubagentCoordinator = class {
 			lease.release();
 		}
 	}
-	async runtimeArchiveSource(graph, scope, view, generation, turn) {
+	async runtimeArchiveSource(graph, scope, view, generation, turn, signal) {
 		if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
-		assertParticipation(graph.config, "memory-spaces", "write", "automatic");
+		if (!allowsParticipation(graph.config, "memory-spaces", "write", "automatic")) return void 0;
 		const candidates = generation.sourceInstances().filter((source) => source.sourceTypeId === "memory-spaces" && view.actionOffers.some((offer) => offer.sourceInstanceKey === source.sourceInstanceKey && offer.sourceActionId === "remember" && offer.authority === void 0));
-		if (candidates.length === 0) throw new Error("Source Action is not offered by the current View: memory-spaces/remember");
+		if (candidates.length === 0) {
+			if (await this.noArchivableMemorySpace(graph, scope, generation, signal)) return void 0;
+			throw new Error("Source Action is not offered by the current View: memory-spaces/remember");
+		}
 		if (candidates.length !== 1) throw new Error("Runtime archival requires one unambiguous writable Memory Spaces Source");
 		const cleanup = graph.source("memory-spaces", scope).forInstance(candidates[0].sourceInstanceKey).forGeneration(generation);
 		let source = cleanup;
@@ -4024,6 +4081,46 @@ var MnemonSubagentCoordinator = class {
 			writeScope: {
 				viewId: view.id,
 				grant
+			},
+			elsewhere: await this.archivableElsewhere(graph, scope, generation, candidates[0].sourceInstanceKey, signal)
+		};
+	}
+	/**
+	* MEMORY.md keeps working without a Memory Space to archive into: the Runtime
+	* Source moves the entries compaction leaves out to its local archive, as exact
+	* text, in the same commit as the compaction and the pending write (#336).
+	*/
+	async archiveRuntimeLocally(context, request, plan, reason, signal) {
+		signal.throwIfAborted();
+		if (plan.localArchive !== true) throw new Error(`runtime memory archival found no Memory Space that can take the archive (${reason}), and this Runtime Source cannot archive locally; pending write was not committed and existing runtime entries are unchanged; update dsh-mnemon-source-runtime, activate a supported Memory Space, or increase runtimeMemory.memoryLimitBytes`);
+		context.assertWritable?.();
+		const runId = `host-${randomUUID()}`;
+		const compacted = plan.entries.map(({ content, importance, branches }) => ({
+			content,
+			importance,
+			...branches === void 0 ? {} : { branches }
+		}));
+		const mutation = await context.runtime.mutateResult("compact-and-mutate", {
+			revision: plan.revision,
+			mutation: request,
+			compacted,
+			maxBytes: compactedBudget(plan),
+			archive: "local"
+		}, signal);
+		const archived = mutation.value.archived?.entries ?? 0;
+		this.counters.migrations += 1;
+		this.counters.lastRunId = runId;
+		this.counters.lastOperation = "migration";
+		this.counters.lastAt = (/* @__PURE__ */ new Date()).toISOString();
+		return {
+			...mutation.value,
+			revision: mutation.revision,
+			maintenance: {
+				kind: "local-archive",
+				runId,
+				provider: "host",
+				summary: `Moved ${archived} MEMORY.md ${archived === 1 ? "entry" : "entries"} to the local archive${mutation.value.archived === void 0 ? "" : ` ${mutation.value.archived.path}`}, since ${reason}.`,
+				memoryBodyIds: []
 			}
 		};
 	}
@@ -4160,15 +4257,22 @@ ${naturalRequest(request)}`;
 			const document = await controller.read("document", { id }, signal);
 			if (document.status !== "active") throw new Error("only active documents can be archived");
 			const source = documentMigrationSource(document);
-			const memoryService = (await this.assertAutomaticMemoryWrite(parent)).forGeneration(lease.generation);
+			const indexSpaces = await this.documentIndexSpaces(parent, lease.generation, signal);
+			if (indexSpaces === void 0) return this.archiveDocumentLocally(controller, document, "no Memory Spaces layer takes writes here", signal);
+			const memoryService = indexSpaces.forGeneration(lease.generation);
 			const identity = await memoryService.identity();
 			const cleanup = graph.source("memory-spaces", agentScope(parent, graph.config)).forInstance(identity.sourceInstanceKey).forGeneration(lease.generation);
 			const grant = authority?.context.view.readGrants.find((grant) => grant.sourceInstanceKey === identity.sourceInstanceKey && grant.schema === "dsh-mnemon.memory-spaces/v1");
 			if (authority !== void 0 && grant === void 0) throw new Error("document archive requires a Memory Space namespace grant");
 			const allowed = grant === void 0 ? void 0 : new Set(strings(object$6(grant.value).memoryBodyIds));
-			const eligible = (body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember && body.provider.capabilities.forget && body.provider.capabilities.writeMode === "exact" && (allowed === void 0 || allowed.has(body.id));
-			const bodies = (await memoryService.read("body-directory", null, signal)).items.filter(eligible);
-			if (bodies.length === 0) throw new Error("document archive requires an existing active Memory Space with exact writes and safe forget");
+			const directory = await memoryService.read("body-directory", null, signal);
+			const indexable = (body) => archivableSpace(directory, body);
+			const eligible = (body) => indexable(body) && (allowed === void 0 || allowed.has(body.id));
+			const bodies = directory.items.filter(eligible);
+			if (bodies.length === 0) {
+				if (!directory.items.some(indexable) && !await this.archivableElsewhere(graph, agentScope(parent, graph.config), lease.generation, identity.sourceInstanceKey, signal)) return this.archiveDocumentLocally(controller, document, "no Memory Space can take its index", signal);
+				throw new Error("document archive requires an existing active Memory Space with exact writes and safe forget");
+			}
 			const { provider, runId, result } = await this.delegate(parent, "document-archive", "Plan managed document archive", documentArchivePrompt(document, source, bodies), [], DOCUMENT_ARCHIVE_SCHEMA, signal, "spawn", DOCUMENT_ARCHIVE_PERSONA);
 			const value = object$6(result.structured);
 			const summary = typeof value.summary === "string" ? value.summary.trim() : "";
@@ -4220,18 +4324,22 @@ ${naturalRequest(request)}`;
 					if (written.length !== 1) throw new Error("document archive requires exactly one index receipt");
 					if (isNew && receiptId !== void 0) destination = destinationFromCommittedMutation(receipt, memoryBodyId, content);
 					else if (states.includes("skipped")) {
-						const exact = (await memoryService.read("search", {
-							query: document.contentHash,
-							mode: "keyword",
-							limit: 50,
-							memoryBodyIds: [memoryBodyId]
-						}, signal)).results.find((item) => item.memoryBodyId === memoryBodyId && item.id === receiptId && item.content === content);
-						if (exact === void 0) throw new Error(`document archive skipped index lacks exact durable evidence in Memory Space ${memoryBodyId}`);
-						destination = {
-							layerId: "memory-spaces",
-							reference: `memory-space:${encodeURIComponent(memoryBodyId)}/item:${encodeURIComponent(exact.id)}`,
-							digest: sha256(exact.content)
-						};
+						const named = skippedExactDestination(receipt, memoryBodyId, content);
+						if (named !== void 0) destination = named;
+						else {
+							const exact = (await memoryService.read("search", {
+								query: document.contentHash,
+								mode: "keyword",
+								limit: 50,
+								memoryBodyIds: [memoryBodyId]
+							}, signal)).results.find((item) => item.memoryBodyId === memoryBodyId && item.id === receiptId && item.content === content);
+							if (exact === void 0) throw new Error(`document archive skipped index lacks exact durable evidence in Memory Space ${memoryBodyId}`);
+							destination = {
+								layerId: "memory-spaces",
+								reference: `memory-space:${encodeURIComponent(memoryBodyId)}/item:${encodeURIComponent(exact.id)}`,
+								digest: sha256(exact.content)
+							};
+						}
 					} else throw new Error(`document archive received no reversible committed index receipt in Memory Space ${memoryBodyId}`);
 				}
 				signal.throwIfAborted();
@@ -4293,6 +4401,7 @@ ${naturalRequest(request)}`;
 		if (plan.entries.length === 0) throw new Error("runtime memory capacity was exceeded without entries available for maintenance");
 		if (request.target === "user") return this.compactUserAndCommit(context, request, plan, signal);
 		const archive = await context.memorySpaces();
+		if (archive === void 0) return this.archiveRuntimeLocally(context, request, plan, "no Memory Space takes automatic writes here", signal);
 		const memoryService = archive.source;
 		let allowed = archive.memoryBodyIds;
 		const readDirectory = async () => {
@@ -4306,13 +4415,16 @@ ${naturalRequest(request)}`;
 			return catalog;
 		};
 		const catalog = await readDirectory();
-		const writable = (body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember === true && (allowed === void 0 || allowed.has(body.id));
-		const eligible = (body) => writable(body) && body.provider.capabilities.writeMode === "exact" && body.provider.capabilities.forget === true;
+		const ready = (body) => catalog.providers?.find((provider) => provider.id === body.provider.id)?.serviceConfigured !== false;
+		const writable = (body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember === true && ready(body) && (allowed === void 0 || allowed.has(body.id));
+		const exact = (body) => body.provider.capabilities.writeMode === "exact" && body.provider.capabilities.forget === true;
+		const eligible = (body) => writable(body) && exact(body);
 		const eligibleBodies = catalog.items.filter(eligible);
 		if (eligibleBodies.length === 0) {
 			const writableBodies = catalog.items.filter(writable);
 			const unsupported = writableBodies.map((body) => `${body.id} (provider=${body.provider.id}, writeMode=${body.provider.capabilities.writeMode}, forget=${body.provider.capabilities.forget})`).join(", ");
 			const reason = catalog.items.length === 0 ? "Memory Space body-directory is empty" : allowed?.size === 0 ? "current View write scope is empty" : allowed !== void 0 && catalog.items.some((body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember && !allowed?.has(body.id)) && writableBodies.length === 0 ? "current View write scope excludes the active writable Memory Spaces" : writableBodies.length === 0 ? "no active writable Memory Space in the authorized scope" : "authorized destinations lack exact writes or safe forget";
+			if (!catalog.items.some((body) => archivableSpace(catalog, body)) && archive.elsewhere !== true) return this.archiveRuntimeLocally(context, request, plan, `${reason}${unsupported === "" ? "" : ` (${unsupported})`}`, signal);
 			const scope = archive.writeScope === void 0 ? "management" : `${archive.writeScope.grant.sourceInstanceKey}/${catalog.writeScope === void 0 ? "pinned-read" : "source-write"}`;
 			throw new Error(`runtime memory archival requires an existing active writable Memory Space with exact writes and safe forget; ${reason}; scope=${scope}, catalog=${catalog.items.length}, authorized=${allowed?.size ?? "management"}, writable=${writableBodies.length}; pending write was not committed and existing runtime entries are unchanged; retry the same request in a new turn after activating a supported authorized Memory Space, or increase runtimeMemory.memoryLimitBytes${unsupported === "" ? "" : `; unsupported destinations: ${unsupported}`}`);
 		}
@@ -4563,12 +4675,18 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 		const committed = destinationFromCommittedMutation(result, memoryBodyId, entry.content);
 		if (committed !== void 0) return committed;
 		if (!mutationStates(result).includes("skipped")) throw new Error(`runtime archive write did not commit synchronously for Memory Space ${memoryBodyId}`);
-		const exact = (await service.read("search", {
+		const named = skippedExactDestination(result, memoryBodyId, entry.content);
+		if (named !== void 0) return named;
+		const recalled = await service.read("search", {
 			query: entry.content.slice(0, 500),
 			limit: 20,
 			memoryBodyIds: [memoryBodyId]
-		}, signal)).results.find((candidate) => candidate.memoryBodyId === memoryBodyId && candidate.content.trim() === entry.content);
-		if (exact === void 0) throw new Error(`runtime archive skipped an entry without exact durable recall evidence in Memory Space ${memoryBodyId}`);
+		}, signal);
+		const exact = recalled.results.find((candidate) => candidate.memoryBodyId === memoryBodyId && candidate.content.trim() === entry.content);
+		if (exact === void 0) {
+			const unavailable = recalled.sources?.find((source) => source.status === "unavailable");
+			throw new Error(`runtime archive skipped an entry without exact durable recall evidence in Memory Space ${memoryBodyId}: ${unavailable === void 0 ? `its search returned ${recalled.results.length} results, none with that exact text` : `its search was unavailable (${safeFailureDetail(unavailable.hint ?? "no detail")})`}`);
+		}
 		return {
 			layerId: "memory-spaces",
 			reference: `memory-space:${encodeURIComponent(memoryBodyId)}/item:${encodeURIComponent(exact.id)}`,
@@ -4832,6 +4950,68 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 		await source.assertActionOffered(actionId, (offer) => authority.graph.config.writeEnabled && offer.authority === void 0);
 		return source;
 	}
+	/**
+	* The Memory Spaces Source a Document archive indexes into, or undefined when
+	* that layer is off, not installed, takes no automatic writes, or has no space
+	* anywhere that could take the index (#336). A space this View does not offer
+	* keeps the refusal, as before.
+	*/
+	async documentIndexSpaces(parent, generation, signal) {
+		const graph = this.runtimeSource.forAgent(parent);
+		if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
+		if (!allowsParticipation(graph.config, "memory-spaces", "write", "automatic")) return void 0;
+		const installed = generation.sourceInstances().filter((source) => source.sourceTypeId === "memory-spaces");
+		if (installed.length === 0) return void 0;
+		const authority = this.turnAuthority(parent, false);
+		if (authority !== void 0 && !authority.context.view.actionOffers.some((offer) => offer.sourceActionId === "remember" && offer.authority === void 0 && installed.some((source) => source.sourceInstanceKey === offer.sourceInstanceKey)) && await this.noArchivableMemorySpace(graph, agentScope(parent, graph.config), generation, signal)) return void 0;
+		return this.writableSourceFor(parent, "memory-spaces", "remember");
+	}
+	/** Whether a Memory Spaces Source other than the one in use lists a space that could take the archive. */
+	async archivableElsewhere(graph, scope, generation, sourceInstanceKey, signal) {
+		if (!generation.sourceInstances().some((source) => source.sourceTypeId === "memory-spaces" && source.sourceInstanceKey !== sourceInstanceKey)) return false;
+		return !await this.noArchivableMemorySpace(graph, scope, generation, signal, sourceInstanceKey);
+	}
+	/**
+	* True only when no installed Memory Spaces Source lists a space that could take
+	* an archive (#336). A directory that cannot be read counts as one that could:
+	* the caller then refuses as before, and nothing leaves working memory.
+	*/
+	async noArchivableMemorySpace(graph, scope, generation, signal, except) {
+		for (const instance of generation.sourceInstances().filter((source) => source.sourceTypeId === "memory-spaces" && source.sourceInstanceKey !== except)) try {
+			const directory = await graph.source("memory-spaces", scope).forInstance(instance.sourceInstanceKey).forGeneration(generation).read("body-directory", null, signal);
+			if (directory.items.some((body) => archivableSpace(directory, body))) return false;
+		} catch {
+			signal?.throwIfAborted();
+			return false;
+		}
+		return true;
+	}
+	/** A Project Document archived without a Mnemon index keeps its original under .mnemon/documents/archived. */
+	async archiveDocumentLocally(controller, document, reason, signal) {
+		signal.throwIfAborted();
+		const summary = `Archived locally without a Mnemon index, since ${reason}.`;
+		const archived = await controller.mutate("archive", {
+			id: document.id,
+			documentRevision: document.revision,
+			summary,
+			memoryBodyIds: []
+		}, signal);
+		const runId = `host-${randomUUID()}`;
+		this.counters.documentArchives += 1;
+		this.counters.lastRunId = runId;
+		this.counters.lastOperation = "document-archive";
+		this.counters.lastAt = (/* @__PURE__ */ new Date()).toISOString();
+		return {
+			...archived,
+			maintenance: {
+				runId,
+				provider: "host",
+				summary,
+				memoryBodyIds: [],
+				archivedDocumentIds: [document.id]
+			}
+		};
+	}
 	async assertAutomaticMemoryWrite(parent) {
 		const graph = this.runtimeSource.forAgent(parent);
 		if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
@@ -5789,7 +5969,7 @@ var MnemonLifecycle = class {
 	};
 	/** Creation ids reserved before DSH publishes clean task-root Agents. */
 	taskAgentIds = /* @__PURE__ */ new Set();
-	/** Bounded process-local replay fence for finalized-message write actions. */
+	/** Bounded process-local replay fence for finalized-message write actions: the latest text per message. */
 	supervisedWritebacks = /* @__PURE__ */ new Map();
 	constructor(ctx, coordinator, config, runtimeSource) {
 		this.ctx = ctx;
@@ -6055,15 +6235,13 @@ var MnemonLifecycle = class {
 		if (normalizedKey === void 0 || normalizedKey === "") return execute();
 		const replayKey = `${replayScope}\u0000${normalizedKey}`;
 		const existing = this.supervisedWritebacks.get(replayKey);
-		if (existing !== void 0) {
-			if (existing.content !== normalizedContent) throw new Error("idempotency key was already used for different content");
-			return existing.result;
-		}
-		if (this.supervisedWritebacks.size >= 256) {
+		if (existing?.content === normalizedContent) return existing.result;
+		if (existing === void 0 && this.supervisedWritebacks.size >= 256) {
 			const oldest = this.supervisedWritebacks.keys().next().value;
 			if (oldest !== void 0) this.supervisedWritebacks.delete(oldest);
 		}
 		const result = execute();
+		this.supervisedWritebacks.delete(replayKey);
 		this.supervisedWritebacks.set(replayKey, {
 			content: normalizedContent,
 			result
@@ -7212,7 +7390,6 @@ async function assisted(runtime, lifecycle, typeId, operation, input, signal, ta
 	if (typeId === "documents") {
 		if (operation === "archive") {
 			requireCapability(runtime, typeId, "archive");
-			requireCapability(runtime, "memory-spaces", "write");
 			return lifecycle.archiveDocument(sessionId, String(input.id ?? ""), workspaceRoot, signal);
 		}
 		if (operation === "mutate") {
@@ -8147,7 +8324,6 @@ function registerTools(ctx, runtimeSource, coordinator) {
 			const agent = requireAgent(exec);
 			if (args.action === "archive") {
 				requireSource(exec, "documents", "archive");
-				requireSource(exec, "memory-spaces", "write");
 				if (isSubagent(agent)) throw new Error("idle document workers cannot cold-archive directly");
 				if (args.id === void 0) throw new Error("document id is required for archive");
 				return coordinator.archiveDocument(agent, args.id, exec.signal);

package/lib/{starter-resolution-DFLhgaoL.js → starter-resolution-UcTGyjgm.js}

@@ -10,15 +10,15 @@ var dependencies = {
 	"dsh-mnemon-provider-holographic": "0.5.6",
 	"dsh-mnemon-provider-honcho": "0.5.5",
 	"dsh-mnemon-provider-mem0": "0.5.5",
-	"dsh-mnemon-provider-mnemon-native": "0.5.8",
+	"dsh-mnemon-provider-mnemon-native": "0.5.9",
 	"dsh-mnemon-provider-openviking": "0.5.7",
 	"dsh-mnemon-provider-retaindb": "0.5.5",
 	"dsh-mnemon-provider-supermemory": "0.5.5",
-	"dsh-mnemon-source-documents": "0.5.9",
-	"dsh-mnemon-source-memory-spaces": "0.5.16",
-	"dsh-mnemon-source-runtime": "0.5.12",
+	"dsh-mnemon-source-documents": "0.5.10",
+	"dsh-mnemon-source-memory-spaces": "0.5.17",
+	"dsh-mnemon-source-runtime": "0.5.13",
 	"dsh-mnemon-strategy-auto-capture": "0.5.5",
-	"dsh-mnemon-strategy-default-three-tier": "0.5.7",
+	"dsh-mnemon-strategy-default-three-tier": "0.5.8",
 	"dsh-mnemon-strategy-general": "0.5.1",
 	"dsh-mnemon-strategy-light-context": "0.5.5",
 	"dsh-mnemon-strategy-scoped": "0.5.5",

package/lib/starter.js

@@ -1,4 +1,4 @@
-import { t as prepareStarterResolution } from "./starter-resolution-DFLhgaoL.js";
+import { t as prepareStarterResolution } from "./starter-resolution-UcTGyjgm.js";
 //#region src/starter.ts
 const name = "dsh-mnemon-starter";
 const provide = ["mnemonStarterReady"];

package/lib/types/src/client/locales.d.ts

@@ -102,6 +102,7 @@ export declare const zh: {
     'receipt.unfinished': string;
     'receipt.failed': string;
     'receipt.view': string;
+    'receipt.viewRuntime': string;
     'taskAgent.ready': string;
     'taskAgent.unavailable': string;
     'saveAction.button': string;
@@ -116,6 +117,31 @@ export declare const zh: {
     'saveAction.submitting': string;
     'saveAction.readOnly': string;
     'saveAction.close': string;
+    'saveAction.hintDirect': string;
+    'saveAction.to': string;
+    'saveAction.to.agent': string;
+    'saveAction.to.agentDetail': string;
+    'saveAction.to.memory': string;
+    'saveAction.to.user': string;
+    'saveAction.to.space': string;
+    'saveAction.save': string;
+    'saveAction.saving': string;
+    'saveAction.saved.runtime': string;
+    'saveAction.saved.runtimeMaintained': string;
+    'saveAction.saved.space': string;
+    'saveAction.saved.spacePending': string;
+    'saveAction.saved.spaceOther': string;
+    'saveAction.saved.duplicate': string;
+    'saveAction.unavailable': string;
+    'saveAction.place.delimiter': string;
+    'saveAction.place.tooLong': string;
+    'saveAction.place.orAgent': string;
+    'saveAction.place.full': string;
+    'saveAction.place.fullAll': string;
+    'saveAction.place.userCondense': string;
+    'saveAction.place.userTooLong': string;
+    'saveAction.place.userFull': string;
+    'saveAction.noPlace': string;
     'readSources.all': string;
     'readSources.mode.search': string;
     'readSources.mode.graph': string;
@@ -980,6 +1006,7 @@ export declare const zh: {
     "documents.updated": string;
     "documents.updatedAfterArchive": string;
     "documents.archived": string;
+    "documents.archivedLocally": string;
     "documents.list": string;
     "documents.activeList": string;
     "documents.archiveList": string;
@@ -999,6 +1026,7 @@ export declare const zh: {
     "documents.hash": string;
     "documents.size": string;
     "documents.archiveReceipt": string;
+    "documents.archiveNote": string;
     "documents.archiveTitle": string;
     "documents.archiveDescription": string;
     "documents.archive": string;
@@ -1048,6 +1076,7 @@ export declare const zh: {
     "runtime.result.remove": string;
     "runtime.result.maintenance": string;
     "runtime.result.localCompaction": string;
+    "runtime.result.localArchive": string;
     "runtime.readOnly": string;
     "runtime.footnote": string;
 };

package/lib/types/src/client/page-controls.d.ts

@@ -48,6 +48,7 @@ export declare function WriteReceipt(props: {
     error?: string | undefined;
     t?: MnemonTranslate | undefined;
     onView?: (() => void) | undefined;
+    viewLabel?: string | undefined;
 }): JSX.Element;
 /** Whether a task Agent can take a write now. */
 export declare function TaskAgentTag(props: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon",
-  "version": "0.5.24",
+  "version": "0.5.25",
   "description": "Composable, view-based memory for DeepSeek Harness. Pluggable sources and strategies, with layered memory out of the box.",
   "keywords": [
     "deepseek-harness",
@@ -157,15 +157,15 @@
     "dsh-mnemon-provider-holographic": "0.5.6",
     "dsh-mnemon-provider-honcho": "0.5.5",
     "dsh-mnemon-provider-mem0": "0.5.5",
-    "dsh-mnemon-provider-mnemon-native": "0.5.8",
+    "dsh-mnemon-provider-mnemon-native": "0.5.9",
     "dsh-mnemon-provider-openviking": "0.5.7",
     "dsh-mnemon-provider-retaindb": "0.5.5",
     "dsh-mnemon-provider-supermemory": "0.5.5",
-    "dsh-mnemon-source-documents": "0.5.9",
-    "dsh-mnemon-source-memory-spaces": "0.5.16",
-    "dsh-mnemon-source-runtime": "0.5.12",
+    "dsh-mnemon-source-documents": "0.5.10",
+    "dsh-mnemon-source-memory-spaces": "0.5.17",
+    "dsh-mnemon-source-runtime": "0.5.13",
     "dsh-mnemon-strategy-auto-capture": "0.5.5",
-    "dsh-mnemon-strategy-default-three-tier": "0.5.7",
+    "dsh-mnemon-strategy-default-three-tier": "0.5.8",
     "dsh-mnemon-strategy-general": "0.5.1",
     "dsh-mnemon-strategy-light-context": "0.5.5",
     "dsh-mnemon-strategy-scoped": "0.5.5",