dsh-mnemon 0.5.21 → 0.5.22

package/lib/client.js

@@ -1854,7 +1854,7 @@ window.__ModuleLoader__.load({
 			"versions.packagesOutdated": "{count} 个有新版本",
 			"versions.packagesDetail": "展开查看维护方式",
 			"versions.packagesHide": "收起子包详情",
-			"versions.packagesHint": "默认组合随主包更新；在当前 Profile 中独立安装的子包可单独更新。更新后重启 dsh web。",
+			"versions.packagesHint": "默认组合随主包更新；在当前 Profile 中独立安装的子包可单独更新。更新后重启 DSH。",
 			"versions.managedStarter": "随主包维护",
 			"versions.managedProfile": "Profile 独立维护",
 			"versions.starterVersion": "主包指定",
@@ -1880,7 +1880,11 @@ window.__ModuleLoader__.load({
 			"versions.updating": "更新中…",
 			"versions.updated": "{name} 已更新",
 			"versions.alreadyCurrent": "当前已经是最新版本",
-			"versions.restartRequired": "请重启 dsh web，以加载新的 dsh-mnemon 插件代码。",
+			"versions.restartRequired": "请重启 DSH 以加载新的 dsh-mnemon 插件代码；桌面版请完全退出后重新打开。",
+			"versions.pendingInstalledTitle": "dsh-mnemon {version} 已安装",
+			"versions.pendingInstalledDetail": "当前运行的仍是 {running}；重启 DSH 后生效，桌面版请完全退出后重新打开。",
+			"versions.pendingPackagesTitle": "{names} 已更新",
+			"versions.pendingPackagesDetail": "重启 DSH 后生效，桌面版请完全退出后重新打开。",
 			"versions.checkedAt": "检查于 {time}",
 			"versions.latestUnavailable": "暂时无法读取远程最新版本；请检查网络后重试。",
 			"versions.modeHomebrew": "Homebrew",
@@ -1892,8 +1896,9 @@ window.__ModuleLoader__.load({
 			"versions.hintHomebrew": "由 Homebrew 管理；发现新版本时可在此安全更新。",
 			"versions.hintBrewMissing": "检测到 Homebrew 安装，但当前找不到 brew 命令。",
 			"versions.hintGo": "由 go install 管理；发现新版本时可在此安全更新。",
-			"versions.hintPnpm": "由当前 DSH Profile 管理；更新后需要重启 dsh web。",
-			"versions.hintPnpmMissing": "检测到 DSH Profile 安装，但当前找不到 pnpm 命令。",
+			"versions.hintDsh": "由当前 DSH Profile 管理；用 DSH 自己的插件安装方式更新，完成后重启 DSH。",
+			"versions.hintPnpm": "由当前 DSH Profile 管理；更新后需要重启 DSH。",
+			"versions.hintPnpmMissing": "检测到 DSH Profile 安装，但宿主找不到 pnpm 命令；安装 pnpm 并重启 DSH 后即可在此更新。",
 			"versions.hintLink": "当前为本地 Link 开发版本；请在源码目录拉取并构建，避免覆盖本地修改。",
 			"versions.hintInstall": "未安装 Mnemon CLI。只有 Mnemon Native 需要它；需要时安装并确保 mnemon 位于 PATH，或设置 MNEMON_CLI_PATH / mnemon.cliPath。",
 			"versions.hintManual": "无法安全识别安装来源；请沿用原安装方式手工更新。",
@@ -2445,7 +2450,7 @@ window.__ModuleLoader__.load({
 			"versions.packagesOutdated": "{count} updates available",
 			"versions.packagesDetail": "Expand for maintenance options",
 			"versions.packagesHide": "Collapse package details",
-			"versions.packagesHint": "Default packages update with the Starter. Packages installed independently in this Profile can update individually. Restart dsh web afterward.",
+			"versions.packagesHint": "Default packages update with the Starter. Packages installed independently in this Profile can update individually. Restart DSH afterward.",
 			"versions.managedStarter": "Maintained with Starter",
 			"versions.managedProfile": "Managed by Profile",
 			"versions.starterVersion": "Starter pin",
@@ -2471,7 +2476,11 @@ window.__ModuleLoader__.load({
 			"versions.updating": "Updating…",
 			"versions.updated": "{name} updated",
 			"versions.alreadyCurrent": "Already on the latest version",
-			"versions.restartRequired": "Restart dsh web to load the new dsh-mnemon plugin code.",
+			"versions.restartRequired": "Restart DSH to load the new dsh-mnemon plugin code; in the desktop app, quit and reopen it.",
+			"versions.pendingInstalledTitle": "dsh-mnemon {version} is installed",
+			"versions.pendingInstalledDetail": "This Host still runs {running}. Restart DSH to load it; in the desktop app, quit and reopen it.",
+			"versions.pendingPackagesTitle": "{names} updated",
+			"versions.pendingPackagesDetail": "Restart DSH to load the update; in the desktop app, quit and reopen it.",
 			"versions.checkedAt": "Checked at {time}",
 			"versions.latestUnavailable": "The remote latest version is unavailable. Check the network and try again.",
 			"versions.modeHomebrew": "Homebrew",
@@ -2483,8 +2492,9 @@ window.__ModuleLoader__.load({
 			"versions.hintHomebrew": "Managed by Homebrew; an available release can be safely updated here.",
 			"versions.hintBrewMissing": "A Homebrew installation was detected, but the brew command is unavailable.",
 			"versions.hintGo": "Managed by go install; an available release can be safely updated here.",
-			"versions.hintPnpm": "Managed by the current DSH Profile; restart dsh web after updating.",
-			"versions.hintPnpmMissing": "A DSH Profile installation was detected, but the pnpm command is unavailable.",
+			"versions.hintDsh": "Managed by the current DSH Profile. Updates use DSH's own plugin installer; restart DSH afterwards.",
+			"versions.hintPnpm": "Managed by the current DSH Profile; restart DSH after updating.",
+			"versions.hintPnpmMissing": "A DSH Profile installation was detected, but the Host cannot find the pnpm command. Install pnpm and restart DSH to update here.",
 			"versions.hintLink": "This is a local linked development build. Pull and build in the source directory to preserve local changes.",
 			"versions.hintInstall": "Mnemon CLI is not installed. Only Mnemon Native needs it; to use Native, install it and place mnemon on PATH, or set MNEMON_CLI_PATH / mnemon.cliPath.",
 			"versions.hintManual": "The installation source cannot be identified safely. Update it using the original installation method.",
@@ -8938,6 +8948,74 @@ window.__ModuleLoader__.load({
 			}
 		};
 		//#endregion
+		//#region src/client/starter-update.ts
+		const STORAGE_KEY = "dsh-mnemon.starter-update";
+		/** An older record belongs to an earlier visit, not to an update this page just ran. */
+		const FRESH_MS = 6e5;
+		function sessionStore() {
+			try {
+				return typeof window === "undefined" ? void 0 : window.sessionStorage;
+			} catch {
+				return;
+			}
+		}
+		function recordStarterUpdate(update, now = Date.now()) {
+			const record = {
+				at: now,
+				...update.from === void 0 ? {} : { from: update.from },
+				...update.to === void 0 ? {} : { to: update.to }
+			};
+			try {
+				sessionStore()?.setItem(STORAGE_KEY, JSON.stringify(record));
+			} catch {}
+		}
+		function clearStarterUpdate() {
+			try {
+				sessionStore()?.removeItem(STORAGE_KEY);
+			} catch {}
+		}
+		function pendingStarterUpdate(now = Date.now()) {
+			let raw;
+			try {
+				raw = sessionStore()?.getItem(STORAGE_KEY);
+			} catch {
+				return;
+			}
+			if (raw === null || raw === void 0) return void 0;
+			let value;
+			try {
+				value = JSON.parse(raw);
+			} catch {
+				value = void 0;
+			}
+			if (!isRecord(value) || typeof value.at !== "number" || now - value.at > FRESH_MS || value.at > now + 6e4) {
+				clearStarterUpdate();
+				return;
+			}
+			return {
+				at: value.at,
+				...typeof value.from === "string" ? { from: value.from } : {},
+				...typeof value.to === "string" ? { to: value.to } : {}
+			};
+		}
+		/** Open the Memory System once it can open, when this page just started a Starter update. */
+		function reopenAfterStarterUpdate(workspace) {
+			if (pendingStarterUpdate() === void 0) return () => {};
+			let unsubscribe;
+			const attempt = () => {
+				const open = workspace.getSnapshot();
+				if (open === void 0) return;
+				unsubscribe?.();
+				unsubscribe = void 0;
+				if (pendingStarterUpdate() !== void 0) open();
+			};
+			unsubscribe = workspace.subscribe(attempt);
+			attempt();
+			return () => {
+				unsubscribe?.();
+			};
+		}
+		//#endregion
 		//#region src/client/change-signal.ts
 		/**
 		* A revision other surfaces bump when something they cannot observe directly
@@ -9233,6 +9311,7 @@ window.__ModuleLoader__.load({
 			if (component.updateHint === "brew") return t("versions.hintHomebrew");
 			if (component.updateHint === "brew-missing") return t("versions.hintBrewMissing");
 			if (component.updateHint === "go") return t("versions.hintGo");
+			if (component.updateHint === "dsh") return t("versions.hintDsh");
 			if (component.updateHint === "pnpm") return t("versions.hintPnpm");
 			if (component.updateHint === "pnpm-missing") return t("versions.hintPnpmMissing");
 			if (component.updateHint === "link") return t("versions.hintLink");
@@ -9353,20 +9432,41 @@ window.__ModuleLoader__.load({
 				setUpdating(component.id);
 				setError(null);
 				setResult(null);
+				if (component.id === "dsh-mnemon") recordStarterUpdate({
+					from: component.current,
+					to: component.latest
+				});
 				try {
 					const next = await props.client.updateVersion(component.id);
 					setResult(next);
 					await check();
 					props.onRefreshStatus();
 				} catch (reason) {
+					if (component.id === "dsh-mnemon") clearStarterUpdate();
 					setError(message(reason));
 				} finally {
 					setUpdating(null);
 					updateInFlight.current = false;
 				}
 			};
+			const close = () => {
+				clearStarterUpdate();
+				props.onClose();
+			};
 			const updatingBusy = updating !== null;
 			const controlsBusy = checking || updatingBusy;
+			const resumed = props.resumedUpdate;
+			const starter = snapshot?.components.find((component) => component.id === "dsh-mnemon");
+			const outcome = result === null && error === null && resumed !== void 0 && snapshot?.lastUpdate?.component === "dsh-mnemon" && Date.parse(snapshot.lastUpdate.at) >= resumed.at - 6e4 ? snapshot.lastUpdate : void 0;
+			const resumedResult = outcome !== void 0 ? outcome.result ?? null : result === null && resumed !== void 0 && snapshot?.lastUpdate === void 0 && starter?.restartRequired === true && (resumed.to === void 0 || starter.current === resumed.to) ? {
+				component: "dsh-mnemon",
+				updated: true,
+				restartRequired: true,
+				...resumed.from === void 0 ? {} : { previousVersion: resumed.from },
+				...starter.current === void 0 ? {} : { currentVersion: starter.current }
+			} : null;
+			const shownResult = result ?? resumedResult;
+			const shownError = error ?? outcome?.error ?? null;
 			const updateButton = (component) => props.writeEnabled && component.outdated && component.updateSupported && component.checkError === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 				type: "button",
 				className: MnemonView_module_css_default.primaryButton,
@@ -9419,7 +9519,7 @@ window.__ModuleLoader__.load({
 				description: t("versions.description"),
 				busy: updatingBusy,
 				contentReady: !checking,
-				onClose: props.onClose,
+				onClose: close,
 				footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 					className: MnemonView_module_css_default.modalFooterMeta,
 					children: snapshot === null ? "" : t("versions.checkedAt", { time: new Date(snapshot.checkedAt).toLocaleTimeString() })
@@ -9437,7 +9537,7 @@ window.__ModuleLoader__.load({
 						"data-dialog-close": true,
 						className: MnemonView_module_css_default.secondaryButton,
 						disabled: updatingBusy,
-						onClick: props.onClose,
+						onClick: close,
 						children: t("common.close")
 					})]
 				})] }),
@@ -9449,19 +9549,19 @@ window.__ModuleLoader__.load({
 							role: "status",
 							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {}), t("versions.checking")]
 						}),
-						error !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						shownError !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 							className: MnemonView_module_css_default.versionError,
 							role: "alert",
-							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: t("versions.failed") }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: error })]
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: t("versions.failed") }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: shownError })]
 						}),
 						!props.writeEnabled && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 							className: MnemonView_module_css_default.versionNotice,
 							children: t("versions.readOnly")
 						}),
-						result !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						shownResult !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 							className: MnemonView_module_css_default.versionResult,
 							role: "status",
-							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: result.updated ? t("versions.updated", { name: result.component === "mnemon" ? "Mnemon CLI" : result.component }) : t("versions.alreadyCurrent") }), result.restartRequired && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("versions.restartRequired") })]
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: shownResult.updated ? t("versions.updated", { name: shownResult.component === "mnemon" ? "Mnemon CLI" : shownResult.component }) : t("versions.alreadyCurrent") }), shownResult.restartRequired && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t("versions.restartRequired") })]
 						}),
 						snapshot !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 							className: MnemonView_module_css_default.versionList,
@@ -9987,8 +10087,19 @@ window.__ModuleLoader__.load({
 		}
 		function StatusPage(props) {
 			const t = useT();
+			const [resumedUpdate, setResumedUpdate] = (0, react.useState)(() => pendingStarterUpdate());
 			const [versionsOpen, setVersionsOpen] = (0, react.useState)(false);
 			const status = props.status;
+			const answered = status !== null || !props.loading;
+			(0, react.useEffect)(() => {
+				if (resumedUpdate === void 0 || !answered) return;
+				if (status !== null && status.restartPending === void 0 && resumedUpdate.to !== void 0 && status.dshMnemonVersion === resumedUpdate.to) {
+					clearStarterUpdate();
+					setResumedUpdate(void 0);
+					return;
+				}
+				setVersionsOpen(true);
+			}, [answered]);
 			const reviewError = status?.lifecycle?.current?.lastError;
 			const storage = status?.storage;
 			const selectedScopeKind = storage?.activeKind ?? "global";
@@ -10056,12 +10167,32 @@ window.__ModuleLoader__.load({
 					versionsOpen && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(VersionDialog, {
 						client: props.client,
 						writeEnabled: props.writeEnabled,
-						onClose: () => setVersionsOpen(false),
+						resumedUpdate,
+						onClose: () => {
+							setResumedUpdate(void 0);
+							setVersionsOpen(false);
+						},
 						onRefreshStatus: props.onRefresh
 					})
 				]
 			});
 		}
+		/**
+		* An installed update waits for DSH to restart: the Host keeps the code it loaded, while DSH has
+		* already swapped in this page. Every Memory System page says so until the restart.
+		*/
+		function RestartReminder({ pending }) {
+			const t = useT();
+			return pending.installed !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Callout, {
+				tone: "warning",
+				title: t("versions.pendingInstalledTitle", { version: pending.installed }),
+				children: t("versions.pendingInstalledDetail", { running: pending.running })
+			}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Callout, {
+				tone: "warning",
+				title: t("versions.pendingPackagesTitle", { names: (pending.packages ?? []).join(t("config.listSeparator")) }),
+				children: t("versions.pendingPackagesDetail")
+			});
+		}
 		/** Mnemon Native is one Provider among peers: it has a health card once its CLI is installed or a space uses it. */
 		function nativeInUse(status) {
 			return status.commandFound || (status.memoryBodies ?? []).some((body) => body.provider.origin === "native");
@@ -10901,6 +11032,10 @@ window.__ModuleLoader__.load({
 							children: notice.detail
 						})
 					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Reveal, {
+						className: MnemonView_module_css_default.notice,
+						children: status?.restartPending !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RestartReminder, { pending: status.restartPending })
+					}),
 					workspaceToast.element,
 					remoteReadOnly && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 						className: MnemonView_module_css_default.alert,
@@ -12055,6 +12190,7 @@ window.__ModuleLoader__.load({
 					activeMemoryWorkspace = void 0;
 				};
 			}, "dsh-mnemon: memory workspace entry");
+			ctx.effect(() => reopenAfterStarterUpdate(seats.workspace), "dsh-mnemon: reopen after a Starter update");
 			const componentSettingsDirectory = createComponentSettingsDirectory(ctx);
 			const configurationServices = () => ({
 				componentSettingsDirectory,

package/lib/index.js

@@ -2376,10 +2376,10 @@ var LiveMnemonRuntime = class {
 	route(request) {
 		this.assertOpen();
 		const effectiveAgent = this.agent(request.sessionId);
-		const effectiveWorkspace = effectiveAgent === void 0 ? void 0 : this.workspaceForPath(effectiveAgent.session.header?.cwd);
+		const effectiveWorkspace = effectiveAgent === void 0 ? this.workspaceForSession(request.sessionId) : this.workspaceForPath(effectiveAgent.session.header?.cwd);
 		const selectedWorkspace = request.workspaceId === void 0 || request.workspaceId.trim() === "" ? effectiveWorkspace : this.requireWorkspace(request.workspaceId);
-		const graph = selectedWorkspace === void 0 ? effectiveAgent === void 0 ? this.current : this.forAgent(effectiveAgent) : isWorkspaceStorageScope(this.current.config.storageScope) ? this.forWorkspacePath(selectedWorkspace.path) : this.current;
-		const effectiveGraph = effectiveAgent === void 0 ? this.current : this.forAgent(effectiveAgent);
+		const effectiveGraph = effectiveAgent !== void 0 ? this.forAgent(effectiveAgent) : effectiveWorkspace !== void 0 && isWorkspaceStorageScope(this.current.config.storageScope) ? this.forWorkspacePath(effectiveWorkspace.path) : this.current;
+		const graph = selectedWorkspace === void 0 ? effectiveGraph : isWorkspaceStorageScope(this.current.config.storageScope) ? this.forWorkspacePath(selectedWorkspace.path) : this.current;
 		const selectedRoot = resolve(graph.directory);
 		const effectiveRoot = resolve(effectiveGraph.directory);
 		return {
@@ -2388,7 +2388,8 @@ var LiveMnemonRuntime = class {
 			...effectiveWorkspace === void 0 ? {} : { effectiveWorkspace },
 			selectedRoot,
 			effectiveRoot,
-			aligned: selectedRoot === effectiveRoot
+			aligned: selectedRoot === effectiveRoot,
+			liveSession: effectiveAgent !== void 0
 		};
 	}
 	forWorkspacePath(workspaceRoot) {
@@ -2424,6 +2425,11 @@ var LiveMnemonRuntime = class {
 		if (workspace === void 0) throw new Error("selected DSH workspace is unavailable");
 		return workspace;
 	}
+	workspaceForSession(sessionId) {
+		const normalized = sessionId?.trim();
+		if (normalized === void 0 || normalized === "") return void 0;
+		return this.workspaceRegistry?.list().find((workspace) => workspace.sessionIds?.includes(normalized) === true);
+	}
 	workspaceForPath(path) {
 		const normalized = path?.trim();
 		if (normalized === void 0 || normalized === "") return void 0;
@@ -2836,6 +2842,112 @@ function reviewCheckpoint(session, maxChars) {
 	return header + (selected.reverse().join("") || "(no eligible text; skip)");
 }
 //#endregion
+//#region src/host/plugin-message.ts
+const MNEMON_PLUGIN_SOURCE = "dsh-mnemon";
+/** A user-role message this plugin adds to a step, marked with its own source. */
+function createPluginMessage(text, form) {
+	return structuredClone({
+		id: randomUUID(),
+		role: "user",
+		content: [{
+			type: "text",
+			text
+		}],
+		source: {
+			kind: MNEMON_PLUGIN_SOURCE,
+			form
+		}
+	});
+}
+//#endregion
+//#region src/host/continuation-turn.ts
+/** The user turn that ends a refused delegated child's tool continuations. */
+const CONTINUATION_TEXT = "Continue from the tool results above.";
+/** How a server reports a chat template that found no user query (Ollama, vLLM and others). */
+const NO_USER_QUERY = /no user query found in messages/iu;
+const startingChild = new AsyncLocalStorage();
+function hasUserText(message) {
+	return message.role === "user" && message.content.some((block) => block.type === "text" && typeof block.text === "string" && block.text.trim() !== "");
+}
+/**
+* Some chat templates refuse a request without a user query: Ollama 0.33
+* serving Qwen3.x answers 500 "no user query found in messages" (#327). A
+* delegated child's only user turn is its prompt. Once tool results fill the
+* model's context window, Ollama truncates from the front and drops that
+* prompt while keeping the tool messages after it.
+*
+* Nothing changes until a server refuses a request that way. The refused step
+* then ends with a short user turn and runs again at once (the server ran no
+* inference), and each later tool continuation of the same child ends the
+* same way, since the server always keeps the last message. A route that never
+* refuses keeps its requests as they are, so a template that shows reasoning
+* only after the last user query keeps the earlier steps' reasoning.
+*/
+function continueAfterRefusal(agent) {
+	if (typeof agent.ctx?.on !== "function") return [];
+	let refused = false;
+	const retried = /* @__PURE__ */ new Set();
+	const turn = () => createPluginMessage(CONTINUATION_TEXT, "instructions");
+	return [agent.ctx.on("agent/request-error", (async (payload, next) => {
+		const step = `${payload.turn}:${payload.step}`;
+		const session = agent.session;
+		if (payload.signal.aborted || payload.step < 2 || retried.has(step) || typeof session.append !== "function" || !NO_USER_QUERY.test(payload.failure?.message ?? "")) return next();
+		retried.add(step);
+		refused = true;
+		session.append("user/message", turn(), { surfaceOp: "append" });
+		return { kind: "retry" };
+	}), { prepend: true }), agent.ctx.on("agent/pre-step", (async (payload, next) => {
+		const decision = await next();
+		if (!refused || payload.step === 1 || payload.signal.aborted || decision.kind !== "enter") return decision;
+		if (payload.messages.length > 0 && decision.messages.length === 0) return decision;
+		if (decision.messages.some(hasUserText)) return decision;
+		return {
+			...decision,
+			messages: [...decision.messages, turn()]
+		};
+	}), { prepend: true })];
+}
+/**
+* Start one delegated child and attach the refusal recovery while DSH
+* publishes it, before its first step. Async context attributes concurrent
+* starts, and DSH's ownership check confirms the parent where it exists. A host
+* that does not report creation leaves the child as it was.
+*/
+async function startWithContinuationTurns(host, parent, start) {
+	const pending = Symbol("Mnemon delegated start");
+	const stops = [];
+	const listener = host.on("agent/created", (({ agent }) => {
+		if (startingChild.getStore() !== pending) return;
+		if (typeof host.agents?.isOwnedBy === "function" && !host.agents.isOwnedBy(agent.id, parent)) return;
+		for (const stop of continueAfterRefusal(agent)) if (typeof stop === "function") stops.push(stop);
+	}));
+	const release = async () => {
+		for (const stop of stops.splice(0)) await stop();
+	};
+	let run;
+	try {
+		run = await startingChild.run(pending, start);
+	} catch (error) {
+		await release();
+		throw error;
+	} finally {
+		if (typeof listener === "function") await listener();
+	}
+	const active = run;
+	return {
+		id: active.id,
+		...active.localAgent === void 0 ? {} : { localAgent: active.localAgent },
+		result: active.result,
+		async dispose() {
+			try {
+				await active.dispose();
+			} finally {
+				await release();
+			}
+		}
+	};
+}
+//#endregion
 //#region src/host/subagent.ts
 function evidenceInsights(evidence) {
 	return evidence.items.map((item) => {
@@ -4572,7 +4684,8 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 				provider: fixed.provider,
 				model: fixed.model
 			};
-			const start = () => this.subagents.start(provider, {
+			const host = this.resultRuntime;
+			const start = () => startWithContinuationTurns(host, parent, () => this.subagents.start(provider, {
 				label,
 				prompt: [{
 					type: "text",
@@ -4584,7 +4697,7 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 				maxDepth: 1,
 				toolFilter: { allow: [...tools, resultToolName] },
 				persona: completionPersona
-			});
+			}));
 			run = operation === "review" ? await startGuardedReview(this.resultRuntime, parent, [...tools, resultToolName], start, (child) => {
 				reviewChildId = child.id;
 			}, reviewLayerPolicy()) : await start();
@@ -5251,21 +5364,6 @@ function llmService(value) {
 	if (typeof value !== "object" || value === null || !("listProviders" in value) || typeof value.listProviders !== "function" || !("listModels" in value) || typeof value.listModels !== "function") return void 0;
 	return value;
 }
-const MNEMON_PLUGIN_SOURCE = "dsh-mnemon";
-function createPluginMessage(text, form) {
-	return structuredClone({
-		id: crypto.randomUUID(),
-		role: "user",
-		content: [{
-			type: "text",
-			text
-		}],
-		source: {
-			kind: MNEMON_PLUGIN_SOURCE,
-			form
-		}
-	});
-}
 function isMnemonMessageSource(source) {
 	if (typeof source !== "object" || source === null) return false;
 	const { kind, plugin } = source;
@@ -5891,6 +5989,16 @@ var MnemonLifecycle = class {
 	mutateDocument(sessionId, request, signal = new AbortController().signal) {
 		return this.coordinator.document(this.liveAgent(sessionId), request, signal);
 	}
+	/**
+	* The same Document write under a fresh task Agent, for a conversation whose
+	* Agent is not loaded: it archives the least recently used Document to make
+	* room, as the conversation's Agent would.
+	*/
+	mutateDocumentTask(sessionId, request, workspaceRoot, signal = new AbortController().signal) {
+		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
+		if (root === void 0 || root.trim() === "") throw new Error("a selected DSH workspace is required to write a Mnemon Document");
+		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.document(agent, request, signal));
+	}
 	archiveDocument(sessionId, id, workspaceRoot, signal = new AbortController().signal) {
 		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
 		if (root === void 0 || root.trim() === "") throw new Error("a selected DSH workspace is required to archive a Mnemon Document");
@@ -5902,6 +6010,11 @@ var MnemonLifecycle = class {
 	placeProvider(sessionId, body, prepared, signal = new AbortController().signal) {
 		return this.coordinator.placeProvider(this.liveAgent(sessionId), body, prepared, signal);
 	}
+	/** Choose a new Memory Space's Provider under a fresh task Agent, as Ask Agent does without a loaded conversation Agent. */
+	placeProviderTask(sessionId, body, prepared, workspaceRoot, signal = new AbortController().signal) {
+		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
+		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.placeProvider(agent, body, prepared, signal));
+	}
 	maintainMetadata(sessionId, memoryBodyIds, workspaceRoot, signal = new AbortController().signal) {
 		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
 		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.maintainMetadata(agent, memoryBodyIds, signal));
@@ -6233,8 +6346,15 @@ function isVersionComponentId(value) {
 }
 const MNEMON_MODULE = "github.com/mnemon-dev/mnemon";
 const PACKAGE_MANIFEST_PATH = [new URL("../package.json", import.meta.url), new URL("../../package.json", import.meta.url)].map((url) => fileURLToPath(url)).find((path) => manifest$1(path)?.name === DSH_MNEMON_PACKAGE) ?? fileURLToPath(new URL("../package.json", import.meta.url));
+/**
+* The version this process loaded. Profiles install with a hoisted layout, so an update rewrites
+* these same files while the loaded modules stay in memory until DSH restarts.
+*/
+const LOADED_VERSION = manifest$1(PACKAGE_MANIFEST_PATH)?.version;
 const CHECK_TIMEOUT_MS = 1e4;
 const UPDATE_TIMEOUT_MS = 6e5;
+/** A check waits this long for an update that is finishing, within the browser's 15 s check deadline. */
+const IN_FLIGHT_WAIT_MS = 3e3;
 const MAX_UPDATE_OUTPUT_BYTES = 16384;
 async function settledWithin(promise, fallback, timeoutMs = 11e3) {
 	let timer;
@@ -6353,6 +6473,10 @@ async function fetchNpmLatest(name, tag = "latest") {
 function dependencySpec(profile, name = DSH_MNEMON_PACKAGE) {
 	return profile?.dependencies?.[name] ?? profile?.devDependencies?.[name];
 }
+/** A dependency the Profile records at one exact version, as DSH's installer writes it. */
+function exactVersion(spec) {
+	return spec !== void 0 && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(spec) ? spec : void 0;
+}
 function isLinkSpec(spec) {
 	return spec !== void 0 && /^(?:link|file|workspace):|^\.{1,2}(?:[/\\]|$)/.test(spec);
 }
@@ -6427,6 +6551,22 @@ async function resultOrThrow(runner, command, args, timeoutMs, options = {}) {
 	}
 	return result;
 }
+/** DSH's failure code with the DSH a release needs, or with the first line of its diagnostic. */
+function dshFailure(change) {
+	const reason = change.error?.code ?? change.application;
+	const incompatible = change.error?.incompatible ?? [];
+	const peers = incompatible.flatMap((plugin) => Object.entries(plugin.peers ?? {}).map(([name, range]) => `${name} ${range}`));
+	if (peers.length > 0) {
+		const runtime = incompatible.find((plugin) => plugin.runtimeVersion !== void 0)?.runtimeVersion;
+		return `${reason} (requires ${peers.join(", ")}${runtime === void 0 ? "" : `; this DSH is ${runtime}`})`;
+	}
+	const lines = (change.error?.diagnostic ?? change.packageResult?.output ?? "").split("\n").map((line) => line.trim()).filter((line) => line !== "");
+	const line = lines.findLast((line) => /ERR_PNPM_[A-Z_]+/.test(line)) ?? lines.findLast((line) => /^(?:\[?error\]?\b|ERROR\b)|\brejected\b/i.test(line)) ?? lines.at(-1);
+	const kind = change.packageResult?.kind;
+	const detail = [kind === void 0 || kind === "unknown" || line?.includes(kind) === true ? void 0 : kind, line?.slice(0, 300)].filter(Boolean).join(": ");
+	const log = change.packageResult?.logPath;
+	return `${reason}${detail === "" ? "" : ` (${detail})`}${log === void 0 || log === "" ? "" : `; log: ${log}`}`;
+}
 function updateOutput(result) {
 	const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n").trim();
 	return output === "" ? void 0 : output.slice(-4e3);
@@ -6449,6 +6589,9 @@ function samePath(left, right) {
 	}
 }
 var VersionUpdateManager = class {
+	/** The version this Host runs; an update changes what is installed, not what is loaded. */
+	runningVersion;
+	/** The Starter the last update installed, read only while the files on disk cannot be. */
 	dshMnemonVersion;
 	packageManifestPath;
 	dshHome;
@@ -6457,20 +6600,73 @@ var VersionUpdateManager = class {
 	executable;
 	fetchNpmLatest;
 	fetchMnemonLatest;
-	pendingRestart = /* @__PURE__ */ new Set();
-	updating = false;
+	bundleInstallerOf;
+	runningProfile;
+	/** What Check versions updated while this Host runs, each with the version it replaced. */
+	pendingRestart = /* @__PURE__ */ new Map();
+	inFlight;
+	lastUpdate;
 	constructor(dependencies = {}) {
 		this.packageManifestPath = dependencies.packageManifestPath ?? PACKAGE_MANIFEST_PATH;
-		this.dshMnemonVersion = manifest$1(this.packageManifestPath)?.version ?? "0.0.0";
+		this.runningVersion = (dependencies.packageManifestPath === void 0 ? LOADED_VERSION : void 0) ?? manifest$1(this.packageManifestPath)?.version ?? "0.0.0";
+		this.dshMnemonVersion = this.runningVersion;
 		this.dshHome = dependencies.dshHome ?? (process.env.DSH_HOME?.trim() || join(homedir(), ".dsh"));
 		this.mnemonCliPath = dependencies.mnemonCliPath ?? (() => findMnemonCommand({}));
 		this.processRunner = dependencies.processRunner ?? runProcess;
 		this.executable = dependencies.resolveExecutable ?? resolveExecutable;
 		this.fetchNpmLatest = dependencies.fetchNpmLatest ?? fetchNpmLatest;
 		this.fetchMnemonLatest = dependencies.fetchMnemonLatest ?? (() => this.fetchNpmLatest(MNEMON_NPM_PACKAGE));
+		this.bundleInstallerOf = dependencies.bundleInstaller ?? (() => void 0);
+		this.runningProfile = dependencies.runningProfile ?? (() => void 0);
 	}
+	/**
+	* DSH's own installer, only for the profile this Host runs in, so it never writes another
+	* profile, and only while DSH has a package manager to run.
+	*/
+	bundleInstaller(install) {
+		if (install.mode !== "npm" || install.profileDir === void 0) return void 0;
+		const installer = this.bundleInstallerOf();
+		if (typeof installer?.installBundle !== "function" || typeof installer.listBundles !== "function") return void 0;
+		const running = this.runningProfile();
+		if (running === void 0 || !running.packageManager && this.executable("pnpm") === void 0) return void 0;
+		try {
+			return realpathSync(running.dir) === realpathSync(install.profileDir) ? installer : void 0;
+		} catch {
+			return;
+		}
+	}
+	/** The Starter installed now, which DSH loads at its next start, however it was installed. */
 	get currentDshMnemonVersion() {
-		return this.dshMnemonVersion;
+		return this.installedVersion(inspectDshInstall(this.packageManifestPath, this.dshHome));
+	}
+	installedVersion(install) {
+		const recorded = install.mode === "npm" && install.profileDir !== void 0 ? exactVersion(dependencySpec(manifest$1(join(install.profileDir, "package.json")))) : void 0;
+		if (recorded !== void 0) return recorded;
+		return manifest$1(install.mode === "npm" && install.profileDir !== void 0 ? packageAt(install.profileDir, DSH_MNEMON_PACKAGE) ?? this.packageManifestPath : this.packageManifestPath)?.version ?? this.dshMnemonVersion;
+	}
+	/** A package Check versions updated, and still not the version it replaced. */
+	replaced(id, current) {
+		return this.pendingRestart.has(id) && current !== this.pendingRestart.get(id);
+	}
+	remember(id, previousVersion) {
+		if (!this.pendingRestart.has(id)) this.pendingRestart.set(id, previousVersion);
+	}
+	/**
+	* What waits for a DSH restart: a Starter on disk other than the one this Host runs, however it
+	* was installed, and the packages Check versions updated on their own.
+	*/
+	restartStatus() {
+		const install = inspectDshInstall(this.packageManifestPath, this.dshHome);
+		const installed = this.installedVersion(install);
+		const pending = [...this.pendingRestart.keys()].filter((id) => id !== DSH_MNEMON_PACKAGE);
+		const rows = pending.length === 0 ? [] : this.subpackages(install).map((row) => row.status);
+		const packages = pending.filter((id) => this.replaced(id, rows.find((row) => row.id === id)?.current)).sort();
+		if (installed === this.runningVersion && packages.length === 0) return void 0;
+		return {
+			running: this.runningVersion,
+			...installed === this.runningVersion ? {} : { installed },
+			...packages.length === 0 ? {} : { packages }
+		};
 	}
 	async latestPackageVersion(name, current) {
 		const channel = current === void 0 ? void 0 : parseSemver(current)?.prerelease[0];
@@ -6634,19 +6830,24 @@ var VersionUpdateManager = class {
 	subpackages(install) {
 		const starterPath = install.mode === "npm" && install.profileDir !== void 0 ? packageAt(install.profileDir, DSH_MNEMON_PACKAGE) ?? this.packageManifestPath : this.packageManifestPath;
 		const starter = manifest$1(starterPath);
+		const starterReplaced = this.installedVersion(install) !== this.runningVersion;
 		const profile = install.profileDir === void 0 ? void 0 : manifest$1(join(install.profileDir, "package.json"));
-		return [.../* @__PURE__ */ new Set([
+		const names = [.../* @__PURE__ */ new Set([
 			...Object.keys(starter?.dependencies ?? {}),
 			...Object.keys(profile?.dependencies ?? {}),
 			...Object.keys(profile?.devDependencies ?? {})
-		])].filter((name) => SUBPACKAGE.test(name)).sort().map((name) => {
+		])].filter((name) => SUBPACKAGE.test(name)).sort();
+		const installer = this.bundleInstaller(install);
+		return names.map((name) => {
 			const directSpec = dependencySpec(profile, name);
 			const managedBy = directSpec === void 0 ? "starter" : "profile";
 			const path = packageAt(directSpec === void 0 ? dirname(starterPath) : install.profileDir, name);
 			const value = path === void 0 ? void 0 : manifest$1(path);
+			const current = (managedBy === "profile" ? exactVersion(directSpec) : void 0) ?? value?.version;
 			const linked = isLinkSpec(directSpec ?? starter?.dependencies?.[name]) || install.mode === "link" || path !== void 0 && !realpathSync(dirname(path)).replaceAll("\\", "/").includes("/node_modules/");
 			const mode = linked ? "link" : path === void 0 ? "missing" : install.mode === "npm" ? "npm" : "manual";
-			const supported = managedBy === "profile" && mode === "npm" && this.executable("pnpm") !== void 0;
+			const throughDsh = managedBy === "profile" && mode === "npm" && installer !== void 0 && value?.dsh?.bundle !== void 0;
+			const supported = managedBy === "profile" && mode === "npm" && (throughDsh || this.executable("pnpm") !== void 0);
 			return {
 				...path === void 0 ? {} : { manifestPath: path },
 				status: {
@@ -6655,19 +6856,20 @@ var VersionUpdateManager = class {
 					kind: SUBPACKAGE.exec(name)[1],
 					managedBy,
 					...starter?.dependencies?.[name] === void 0 ? {} : { expectedVersion: starter.dependencies[name] },
-					...value?.version === void 0 ? {} : { current: value.version },
+					...current === void 0 ? {} : { current },
 					...path === void 0 ? {} : { installPath: realpathSync(dirname(path)) },
 					...install.profileName === void 0 ? {} : { installProfile: install.profileName },
 					installMode: mode,
 					outdated: false,
 					updateSupported: supported,
-					updateHint: linked ? "link" : managedBy === "starter" ? "starter" : supported ? "pnpm" : mode === "npm" ? "pnpm-missing" : "manual",
-					restartRequired: this.pendingRestart.has(name) || this.pendingRestart.has(DSH_MNEMON_PACKAGE)
+					updateHint: linked ? "link" : managedBy === "starter" ? "starter" : throughDsh ? "dsh" : supported ? "pnpm" : mode === "npm" ? "pnpm-missing" : "manual",
+					restartRequired: this.replaced(name, current) || starterReplaced
 				}
 			};
 		});
 	}
 	async check() {
+		if (this.inFlight !== void 0) await settledWithin(this.inFlight, void 0, IN_FLIGHT_WAIT_MS);
 		const dshInstall = inspectDshInstall(this.packageManifestPath, this.dshHome);
 		const [mnemonLocal, mnemonLatest, dshLatest, packages] = await Promise.all([
 			settledWithin(this.inspectMnemon(), { install: {
@@ -6686,25 +6888,28 @@ var VersionUpdateManager = class {
 			}))
 		]);
 		const pnpm = this.executable("pnpm");
+		const installer = this.bundleInstaller(dshInstall);
 		const mnemonOutdated = mnemonLocal.current !== void 0 && mnemonLatest !== void 0 && compareVersions(mnemonLocal.current, mnemonLatest) < 0;
-		const dshOutdated = dshLatest !== void 0 && compareVersions(this.currentDshMnemonVersion, dshLatest) < 0;
+		const installed = this.installedVersion(dshInstall);
+		const dshOutdated = dshLatest !== void 0 && compareVersions(installed, dshLatest) < 0;
 		const mnemonSupported = mnemonLocal.install.updateCommand !== void 0;
-		const dshSupported = dshInstall.mode === "npm" && dshInstall.profileDir !== void 0 && pnpm !== void 0;
+		const dshSupported = dshInstall.mode === "npm" && dshInstall.profileDir !== void 0 && (installer !== void 0 || pnpm !== void 0);
 		return {
 			checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...this.lastUpdate === void 0 ? {} : { lastUpdate: this.lastUpdate },
 			components: [{
 				id: "dsh-mnemon",
 				name: "dsh-mnemon",
 				...dshInstall.profileName === void 0 ? {} : { installProfile: dshInstall.profileName },
 				installPath: dshInstall.locationDir,
-				current: this.currentDshMnemonVersion,
+				current: installed,
 				...dshLatest === void 0 ? {} : { latest: dshLatest },
 				outdated: dshOutdated,
 				installMode: dshInstall.mode,
 				updateSupported: dshSupported,
 				packages,
-				restartRequired: this.pendingRestart.size > 0,
-				updateHint: dshInstall.mode === "npm" ? dshSupported ? "pnpm" : "pnpm-missing" : dshInstall.mode === "link" ? "link" : "manual",
+				restartRequired: this.restartStatus() !== void 0,
+				updateHint: dshInstall.mode === "npm" ? installer !== void 0 ? "dsh" : dshSupported ? "pnpm" : "pnpm-missing" : dshInstall.mode === "link" ? "link" : "manual",
 				...dshLatest === void 0 ? { checkError: "latest-unavailable" } : {}
 			}, {
 				id: "mnemon",
@@ -6721,12 +6926,26 @@ var VersionUpdateManager = class {
 		};
 	}
 	async update(component) {
-		if (this.updating) throw new Error("A version update is already in progress");
-		this.updating = true;
+		if (this.inFlight !== void 0) throw new Error("A version update is already in progress");
+		const run = this.performUpdate(component);
+		this.inFlight = run;
 		try {
-			return await this.performUpdate(component);
+			const result = await run;
+			this.lastUpdate = {
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				component,
+				result
+			};
+			return result;
+		} catch (error) {
+			this.lastUpdate = {
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				component,
+				error: error instanceof Error ? error.message : String(error)
+			};
+			throw error;
 		} finally {
-			this.updating = false;
+			this.inFlight = void 0;
 		}
 	}
 	async performUpdate(component) {
@@ -6768,8 +6987,10 @@ var VersionUpdateManager = class {
 			previousVersion,
 			currentVersion: previousVersion,
 			updated: false,
-			restartRequired: this.pendingRestart.has(component)
+			restartRequired: component === DSH_MNEMON_PACKAGE ? previousVersion !== this.runningVersion : this.replaced(component, previousVersion)
 		};
+		const installer = child === void 0 || child.updateHint === "dsh" ? this.bundleInstaller(install) : void 0;
+		if (installer !== void 0) return this.updateThroughDsh(installer, component, previousVersion, latest);
 		const pnpm = this.executable("pnpm");
 		if (install.mode !== "npm" || install.profileDir === void 0 || pnpm === void 0) throw new Error("This dsh-mnemon installation cannot be updated automatically");
 		const output = await resultOrThrow(this.processRunner, pnpm, [
@@ -6781,7 +7002,7 @@ var VersionUpdateManager = class {
 		if (installedVersion !== latest) throw new Error(`${component} update did not install the requested version ${latest}; found ${installedVersion ?? "no package"}`);
 		const outputText = updateOutput(output);
 		if (component === DSH_MNEMON_PACKAGE) this.dshMnemonVersion = installedVersion;
-		this.pendingRestart.add(component);
+		this.remember(component, previousVersion);
 		return {
 			component,
 			previousVersion,
@@ -6791,6 +7012,33 @@ var VersionUpdateManager = class {
 			...outputText === void 0 ? {} : { output: outputText }
 		};
 	}
+	/**
+	* An exact version installs at once, outside pnpm's release-age window, and for the Starter pins
+	* its tested components. The update replaces the package only; which bundles run stays as it was.
+	*/
+	async updateThroughDsh(installer, component, previousVersion, latest) {
+		const spec = `${component}@${latest}`;
+		let change;
+		try {
+			change = await installer.installBundle(spec, { enabled: false });
+		} catch (error) {
+			throw new Error(`DSH could not install ${spec}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const output = change.packageResult?.output?.trim();
+		if (change.application === "failed" || change.application === "cancelled") throw new Error(`DSH could not install ${spec}: ${dshFailure(change)}`);
+		const installedVersion = (await installer.listBundles()).find((bundle) => bundle.name === component)?.version;
+		if (installedVersion !== latest) throw new Error(`${component} update did not install the requested version ${latest}; found ${installedVersion ?? "no package"}`);
+		if (component === DSH_MNEMON_PACKAGE) this.dshMnemonVersion = installedVersion;
+		this.remember(component, previousVersion);
+		return {
+			component,
+			previousVersion,
+			currentVersion: installedVersion,
+			updated: true,
+			restartRequired: true,
+			...output === void 0 || output === "" ? {} : { output: output.slice(-4e3) }
+		};
+	}
 };
 //#endregion
 //#region src/host/rpc.ts
@@ -6970,7 +7218,13 @@ async function assisted(runtime, lifecycle, typeId, operation, input, signal, ta
 		if (operation === "mutate") {
 			requireCapability(runtime, typeId, "write");
 			const request = input;
-			return runtime.aligned && sessionId !== "" ? lifecycle.mutateDocument(sessionId, request, signal) : runtime.source(typeId).mutate("mutate", request, signal);
+			if (runtime.aligned && runtime.liveSession && sessionId !== "") return lifecycle.mutateDocument(sessionId, request, signal);
+			try {
+				return await runtime.source(typeId).mutate("mutate", request, signal);
+			} catch (error) {
+				if (!runtime.aligned || sessionId === "" || !sourceFailure(error, "document-capacity")) throw error;
+				return lifecycle.mutateDocumentTask(sessionId, request, workspaceRoot, signal);
+			}
 		}
 	}
 	if (typeId !== "memory-spaces") throw new Error("unsupported Source assistance operation");
@@ -6994,10 +7248,11 @@ async function assisted(runtime, lifecycle, typeId, operation, input, signal, ta
 			if (request.placement === void 0) return source.mutate("body-create", request, signal);
 			requireAligned(runtime);
 			const prepared = await source.read("prepare-body-placement", request, signal);
-			const placementDecision = await lifecycle.placeProvider(sessionId, {
+			const body = {
 				name: request.name,
 				description: request.description
-			}, prepared, signal);
+			};
+			const placementDecision = runtime.liveSession ? await lifecycle.placeProvider(sessionId, body, prepared, signal) : await lifecycle.placeProviderTask(sessionId, body, prepared, workspaceRoot, signal);
 			return source.mutate("body-create", {
 				request,
 				placementDecision
@@ -7082,6 +7337,10 @@ function createReadHandler(input, lifecycle, versions) {
 						documents = await runtime.source("documents").read("snapshot", null, signal);
 					} catch {}
 					const composition = await compositionStatus(runtime);
+					let restartPending;
+					try {
+						restartPending = versions?.restartStatus();
+					} catch {}
 					return success$1({
 						...composition.sources.some((source) => source.sourceTypeId === "memory-spaces") ? await runtime.source("memory-spaces").read(endpoint, payload, signal) : {
 							healthy: composition.evaluation.state === "ready",
@@ -7093,7 +7352,8 @@ function createReadHandler(input, lifecycle, versions) {
 							writeEnabled: runtime.graph.config.writeEnabled,
 							defaultRecallLimit: runtime.graph.config.defaultRecallLimit
 						},
-						...versions === void 0 ? {} : { dshMnemonVersion: versions.currentDshMnemonVersion },
+						...versions === void 0 ? {} : { dshMnemonVersion: versions.runningVersion },
+						...restartPending === void 0 ? {} : { restartPending },
 						...lifecycle === void 0 ? {} : { lifecycle: lifecycle.snapshot(runtime.scope.sessionId, isWorkspaceStorageScope(runtime.graph.config.storageScope) ? runtime.scope.workspaceId : void 0) },
 						...documents === void 0 ? {} : { documents },
 						memorySystem: composition,
@@ -7248,7 +7508,7 @@ function createWriteHandler(input, lifecycle, versions) {
 			}
 			if (Object.hasOwn(SPACE_WRITE_CAPABILITIES, endpoint)) {
 				requireCapability(runtime, "memory-spaces", SPACE_WRITE_CAPABILITIES[endpoint]);
-				if (endpoint === "remember" && lifecycle !== void 0 && runtime.aligned && runtime.scope.sessionId) return success$1(await lifecycle.remember(runtime.scope.sessionId, {
+				if (endpoint === "remember" && lifecycle !== void 0 && runtime.aligned && runtime.liveSession && runtime.scope.sessionId) return success$1(await lifecycle.remember(runtime.scope.sessionId, {
 					...payload,
 					source: "user"
 				}, signal));
@@ -9156,8 +9416,8 @@ function createViewHandler(runtime, engine, management, access, lifecycle, insta
 				...sessionId === void 0 ? {} : { sessionId },
 				...selectedWorkspaceId === void 0 ? {} : { workspaceId: selectedWorkspaceId }
 			});
-			const workspaceId = route.selectedWorkspace?.path ?? lifecycle?.workspaceRoot(sessionId);
-			const sessionWorkspace = lifecycle?.workspaceRoot(sessionId);
+			const sessionWorkspace = lifecycle?.workspaceRoot(sessionId) ?? route.effectiveWorkspace?.path;
+			const workspaceId = route.selectedWorkspace?.path ?? sessionWorkspace;
 			const aligned = route.aligned && (route.selectedWorkspace === void 0 || sessionId === void 0 || sessionWorkspace !== void 0 && resolve(route.selectedWorkspace.path) === resolve(sessionWorkspace));
 			const config = management.resolveConfig(runtime.config);
 			const scope = {
@@ -10276,7 +10536,18 @@ function apply(rawContext, rawConfig = {}) {
 	ctx.inject(["connection", "webServer"], (webContext) => {
 		const connection = Context.is(webContext) ? webContext.extend({ webServer: webContext.get("webServer") }).connection : webContext.connection;
 		if (connection === void 0) return;
-		const rpc = registerRpc(connection, runtime, lifecycle);
+		const versions = new VersionUpdateManager({
+			mnemonCliPath: () => runtime.config.cliPath,
+			bundleInstaller: () => ctx.get("pluginManager"),
+			runningProfile: () => {
+				const profile = ctx.get("profileContext");
+				return typeof profile?.dir === "string" ? {
+					dir: profile.dir,
+					packageManager: profile.packageManager !== void 0
+				} : void 0;
+			}
+		});
+		const rpc = registerRpc(connection, runtime, lifecycle, versions);
 		const settings = registerSettingsRpc(connection, hostSettings);
 		const view = registerViewRpc(connection, runtime, extensions, memoryPlugins, lifecycle, pluginInstallation);
 		if (Context.is(webContext)) new MnemonRemoteService(webContext, {

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

@@ -268,6 +268,10 @@ export declare const zh: {
     'versions.updated': string;
     'versions.alreadyCurrent': string;
     'versions.restartRequired': string;
+    'versions.pendingInstalledTitle': string;
+    'versions.pendingInstalledDetail': string;
+    'versions.pendingPackagesTitle': string;
+    'versions.pendingPackagesDetail': string;
     'versions.checkedAt': string;
     'versions.latestUnavailable': string;
     'versions.modeHomebrew': string;
@@ -279,6 +283,7 @@ export declare const zh: {
     'versions.hintHomebrew': string;
     'versions.hintBrewMissing': string;
     'versions.hintGo': string;
+    'versions.hintDsh': string;
     'versions.hintPnpm': string;
     'versions.hintPnpmMissing': string;
     'versions.hintLink': string;

package/lib/types/src/host/protocol.d.ts

@@ -486,7 +486,10 @@ export interface StatusView {
     healthy: boolean;
     error?: string;
     version?: string;
+    /** The dsh-mnemon version this Host runs, which an installed update replaces only when DSH restarts. */
     dshMnemonVersion?: string;
+    /** Updates installed while this Host runs; they load when DSH restarts. */
+    restartPending?: VersionRestartStatus;
     cliPath: string;
     commandFound: boolean;
     dataDir: string;
@@ -606,6 +609,24 @@ export interface VersionPackageStatus extends VersionComponentStatus {
 export interface VersionStatus {
     checkedAt: string;
     components: VersionComponentStatus[];
+    /** How the last update this Host ran from Check versions ended, for a page DSH swapped in meanwhile. */
+    lastUpdate?: VersionUpdateOutcome;
+}
+export interface VersionUpdateOutcome {
+    at: string;
+    component: VersionComponentId;
+    /** The update's reply, when it ended without an error. */
+    result?: VersionUpdateResult;
+    /** Why it failed, when it did. */
+    error?: string;
+}
+export interface VersionRestartStatus {
+    /** The dsh-mnemon version this Host runs. */
+    running: string;
+    /** The dsh-mnemon version now installed, when it differs, however it was installed: Check versions or `dsh plugin`, for example. */
+    installed?: string;
+    /** Packages Check versions updated on their own. */
+    packages?: VersionPackageId[];
 }
 export interface VersionUpdateResult {
     component: VersionComponentId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon",
-  "version": "0.5.21",
+  "version": "0.5.22",
   "description": "Composable, view-based memory for DeepSeek Harness. Pluggable sources and strategies, with layered memory out of the box.",
   "keywords": [
     "deepseek-harness",