dsh-mnemon 0.1.1 → 0.1.3

package/lib/index.js

@@ -1,19 +1,19 @@
 import z from "schemastery";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
-import { accessSync, closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { strToU8, unzipSync, zipSync } from "fflate";
 import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
 //#region lib/types/config-values.js
 const DEFAULT_TIMEOUT_MS = 1e4;
 const DEFAULT_IDLE_REVIEW_MS = 3e4;
 //#endregion
 //#region lib/types/config.js
 const InteractionConfig = z.object({
-	toolviews: z.boolean().default(false),
-	turnBar: z.boolean().default(false),
-	saveAction: z.boolean().default(false)
+	turnBar: z.boolean().default(true),
+	saveAction: z.boolean().default(true)
 });
 const Config = z.object({
 	storageScope: z.union([
@@ -33,6 +33,7 @@ const Config = z.object({
 	timeoutMs: z.number().step(1).min(100).max(12e4).default(DEFAULT_TIMEOUT_MS),
 	defaultRecallLimit: z.number().step(1).min(1).max(50).default(10),
 	routingGuidance: z.boolean().default(true),
+	displayMode: z.union(["sidebar", "buildin"]).default("sidebar"),
 	tabEnabled: z.boolean().default(true),
 	writeEnabled: z.boolean().default(true),
 	lifecycleEnabled: z.boolean().default(true),
@@ -41,19 +42,18 @@ const Config = z.object({
 	idleReviewMs: z.number().step(1).min(5e3).max(6e5).default(DEFAULT_IDLE_REVIEW_MS),
 	conversationInteraction: z.object({
 		toolviews: z.boolean().default(false),
-		turnBar: z.boolean().default(false),
-		saveAction: z.boolean().default(false)
+		turnBar: z.boolean().default(true),
+		saveAction: z.boolean().default(true)
 	}).default({
 		toolviews: false,
-		turnBar: false,
-		saveAction: false
+		turnBar: true,
+		saveAction: true
 	})
 });
 function resolveInteractionConfig(config = {}) {
 	return {
-		toolviews: config.toolviews ?? false,
-		turnBar: config.turnBar ?? false,
-		saveAction: config.saveAction ?? false
+		turnBar: config.turnBar ?? true,
+		saveAction: config.saveAction ?? true
 	};
 }
 function optionalText$1(value) {
@@ -117,6 +117,7 @@ function resolveConfig(config = {}) {
 		timeoutMs: config.timeoutMs ?? 1e4,
 		defaultRecallLimit: config.defaultRecallLimit ?? 10,
 		routingGuidance: config.routingGuidance ?? true,
+		displayMode: config.displayMode ?? "sidebar",
 		tabEnabled: config.tabEnabled ?? true,
 		writeEnabled: config.writeEnabled ?? true,
 		lifecycleEnabled: config.lifecycleEnabled ?? true,
@@ -125,13 +126,16 @@ function resolveConfig(config = {}) {
 		idleReviewMs: config.idleReviewMs ?? 3e4,
 		conversationInteraction: {
 			toolviews: config.conversationInteraction?.toolviews ?? false,
-			turnBar: config.conversationInteraction?.turnBar ?? false,
-			saveAction: config.conversationInteraction?.saveAction ?? false
+			turnBar: config.conversationInteraction?.turnBar ?? true,
+			saveAction: config.conversationInteraction?.saveAction ?? true
 		}
 	};
 }
 //#endregion
 //#region lib/types/commands.js
+function isAgentServiceSource(value) {
+	return "forAgent" in value && typeof value.forAgent === "function";
+}
 const USAGE = "用法：/mnemon [status|recall <查询>|related <ID>|remember <内容>|forget <ID>]";
 function error(text) {
 	return {
@@ -166,7 +170,8 @@ function splitInput(rawInput) {
 		argument: input.slice(separator).trim()
 	};
 }
-async function execute(service, coordinator, invocation) {
+async function execute(serviceOrSource, coordinator, invocation) {
+	const service = isAgentServiceSource(serviceOrSource) ? serviceOrSource.forAgent(invocation.agent).service : serviceOrSource;
 	const { verb, argument } = splitInput(invocation.rawInput);
 	switch (verb) {
 		case "status": {
@@ -762,26 +767,19 @@ var DocumentManager = class {
 	}
 	forWorkspace(workspaceRoot) {
 		const root = resolve(workspaceRoot);
-		let controller = this.controllers.get(root);
+		const storageRoot = this.storageRoot?.();
+		const key = storageRoot === void 0 ? root : `${resolve(storageRoot)}\0${root}`;
+		let controller = this.controllers.get(key);
 		if (controller === void 0) {
-			controller = new DocumentController(root, this.limitBytes, this.now);
-			this.controllers.set(root, controller);
+			controller = new DocumentController(root, this.limitBytes, this.now, storageRoot);
+			this.controllers.set(key, controller);
 		}
 		return controller;
 	}
 	forAgent(agent) {
 		const cwd = agent.session.header?.cwd;
 		if (cwd === void 0 || cwd.trim() === "") throw new Error("the current DSH session has no workspace for Mnemon Documents");
-		if (this.storageRoot === void 0) return this.forWorkspace(cwd);
-		const storageRoot = resolve(this.storageRoot());
-		const root = resolve(cwd);
-		const key = `${storageRoot}\0${root}`;
-		let controller = this.controllers.get(key);
-		if (controller === void 0) {
-			controller = new DocumentController(root, this.limitBytes, this.now, storageRoot);
-			this.controllers.set(key, controller);
-		}
-		return controller;
+		return this.forWorkspace(cwd);
 	}
 };
 //#endregion
@@ -792,6 +790,9 @@ const ROUTING_GUIDANCE = "Use memory only by need. For substantial project recor
 function systemPrompt(ctx) {
 	return ctx.get("systemPrompt");
 }
+function scopedSystemPrompt(agent) {
+	return agent.ctx.get?.("systemPrompt");
+}
 function registerGuidance(ctx, config) {
 	systemPrompt(ctx)?.section?.({
 		name: GUIDANCE_SECTION_NAME,
@@ -807,6 +808,15 @@ function registerRuntimeMemoryContext(ctx, runtimeMemory) {
 		text: () => runtimeMemory.contextText()
 	});
 }
+/** Shadow the global fallback with the current Agent workspace's hot memory. */
+function registerAgentRuntimeMemoryContext(agent, runtimeMemory) {
+	const dispose = scopedSystemPrompt(agent)?.section?.({
+		name: RUNTIME_MEMORY_SECTION_NAME,
+		order: 145,
+		text: () => runtimeMemory().contextText()
+	});
+	return typeof dispose === "function" ? dispose : () => {};
+}
 const RUNTIME_ENTRY_DELIMITER = "\n§\n";
 const RUNTIME_MEMORY_LIMITS = {
 	memory: 10240,
@@ -2078,7 +2088,7 @@ function expandHome$1(path) {
 	if (path === "~") return homedir();
 	return path.startsWith("~/") ? join(homedir(), path.slice(2)) : path;
 }
-function executable(path) {
+function executable$1(path) {
 	try {
 		accessSync(path, constants.X_OK);
 		return true;
@@ -2092,7 +2102,7 @@ function findMnemonCommand(config) {
 	const envPath = process.env.MNEMON_CLI_PATH?.trim();
 	if (envPath !== void 0 && envPath !== "") {
 		const path = expandHome$1(envPath);
-		if (executable(path)) return path;
+		if (executable$1(path)) return path;
 	}
 	for (const directory of (process.env.PATH ?? "").split(delimiter)) {
 		if (directory === "") continue;
@@ -2102,12 +2112,12 @@ function findMnemonCommand(config) {
 			"mnemon"
 		] : ["mnemon"]) {
 			const path = join(directory, name);
-			if (executable(path)) return path;
+			if (executable$1(path)) return path;
 		}
 	}
 	for (const candidate of COMMON_CLI_PATHS) {
 		const path = expandHome$1(candidate);
-		if (executable(path)) return path;
+		if (executable$1(path)) return path;
 	}
 }
 var MnemonCliError = class extends Error {
@@ -2120,7 +2130,7 @@ var MnemonCliError = class extends Error {
 		this.stderr = stderr;
 	}
 };
-function createRunner(config, processRunner = runProcess) {
+function createRunner(config, processRunner = runProcess, workspaceRoot) {
 	const found = findMnemonCommand(config);
 	const command = found ?? config.cliPath ?? "mnemon";
 	let processQueue = Promise.resolve();
@@ -2132,7 +2142,7 @@ function createRunner(config, processRunner = runProcess) {
 		return args;
 	};
 	const effectiveDataDir = () => {
-		if (config.storageScope === "workspace") return resolve(process.cwd(), ".mnemon");
+		if (config.storageScope === "workspace") return resolve(workspaceRoot ?? process.cwd(), ".mnemon");
 		if (config.storageScope === "custom") return expandHome$1(config.dataDir);
 		return expandHome$1(process.env.MNEMON_DATA_DIR?.trim() || "~/.mnemon");
 	};
@@ -2162,7 +2172,7 @@ function createRunner(config, processRunner = runProcess) {
 	};
 	return {
 		command,
-		commandFound: found !== void 0 && executable(found),
+		commandFound: found !== void 0 && executable$1(found),
 		config,
 		async runJson(args, options) {
 			const stdout = await execute(args, options);
@@ -2289,6 +2299,20 @@ var MemoryBodyRegistry = class {
 		this.save();
 		return this.view(body);
 	}
+	async remove(id, signal) {
+		const body = this.get(id);
+		await this.runner.runText([
+			"store",
+			"remove",
+			body.id
+		], {
+			...signal === void 0 ? {} : { signal },
+			store: body.id
+		});
+		this.bodies = this.bodies.filter((entry) => entry.id !== body.id);
+		this.save();
+		return body;
+	}
 	setActive(id, active) {
 		return this.update(id, { active });
 	}
@@ -2774,6 +2798,10 @@ var MnemonService = class {
 		this.assertWritable();
 		return this.memoryBodies.update(id, request);
 	}
+	async deleteBody(id, signal) {
+		this.assertWritable();
+		return this.memoryBodies.remove(id, signal);
+	}
 	async mergeBodies(targetBodyId, sourceBodyIds, deactivateSources = true, signal) {
 		this.assertWritable();
 		const target = this.memoryBodies.get(targetBodyId);
@@ -3223,8 +3251,8 @@ var StorageScopeInspector = class {
 * validate and initialize the selected storage root, so a failed candidate is
 * rejected by DSH settings validation without disturbing the active graph.
 */
-function createRuntimeGraph(config) {
-	const runner = createRunner(config);
+function createRuntimeGraph(config, workspaceRoot) {
+	const runner = createRunner(config, void 0, workspaceRoot);
 	const service = new MnemonService(runner, config);
 	return {
 		config,
@@ -3268,7 +3296,10 @@ function liveProxy(resolve) {
 * generation until that invocation settles.
 */
 var LiveMnemonRuntime = class {
+	workspaceRegistry;
+	agents;
 	current;
+	workspaceGraphs = /* @__PURE__ */ new Map();
 	config;
 	runner;
 	service;
@@ -3276,7 +3307,9 @@ var LiveMnemonRuntime = class {
 	documents;
 	storage;
 	packs;
-	constructor(initial) {
+	constructor(initial, workspaceRegistry, agents) {
+		this.workspaceRegistry = workspaceRegistry;
+		this.agents = agents;
 		this.current = initial;
 		this.config = liveProxy(() => this.current.config);
 		this.runner = liveProxy(() => this.current.runner);
@@ -3288,13 +3321,72 @@ var LiveMnemonRuntime = class {
 	}
 	swap(next) {
 		this.current = next;
+		this.workspaceGraphs.clear();
 	}
 	snapshot() {
 		return this.current;
 	}
+	/** Resolve the runtime that must serve one Agent execution. */
+	forAgent(agent) {
+		if (this.current.config.storageScope !== "workspace") return this.current;
+		const cwd = agent.session.header?.cwd?.trim();
+		if (cwd === void 0 || cwd === "") throw new Error("the current DSH session has no workspace for Mnemon");
+		return this.forWorkspacePath(cwd);
+	}
+	/** Resolve an authorized DSH workspace selected by the Web workbench. */
+	forWorkspaceId(workspaceId) {
+		const workspace = this.requireWorkspace(workspaceId);
+		return this.current.config.storageScope === "workspace" ? this.forWorkspacePath(workspace.path) : this.current;
+	}
+	/** Resolve a Web request, preferring its explicit inspection workspace. */
+	route(request) {
+		const effectiveAgent = this.agent(request.sessionId);
+		const effectiveWorkspace = effectiveAgent === void 0 ? void 0 : 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) : this.current.config.storageScope === "workspace" ? this.forWorkspacePath(selectedWorkspace.path) : this.current;
+		const effectiveGraph = effectiveAgent === void 0 ? this.current : this.forAgent(effectiveAgent);
+		const selectedRoot = resolve(graph.runner.effectiveDataDir());
+		const effectiveRoot = resolve(effectiveGraph.runner.effectiveDataDir());
+		return {
+			graph,
+			...selectedWorkspace === void 0 ? {} : { selectedWorkspace },
+			...effectiveWorkspace === void 0 ? {} : { effectiveWorkspace },
+			selectedRoot,
+			effectiveRoot,
+			aligned: selectedRoot === effectiveRoot
+		};
+	}
+	forWorkspacePath(workspaceRoot) {
+		const key = resolve(workspaceRoot);
+		let graph = this.workspaceGraphs.get(key);
+		if (graph === void 0) {
+			graph = createRuntimeGraph(this.current.config, key);
+			this.workspaceGraphs.set(key, graph);
+		}
+		return graph;
+	}
+	agent(sessionId) {
+		const normalized = sessionId?.trim();
+		return normalized === void 0 || normalized === "" ? void 0 : this.agents?.get(normalized);
+	}
+	requireWorkspace(workspaceId) {
+		const normalized = workspaceId.trim();
+		const workspace = normalized === "" ? void 0 : this.workspaceRegistry?.get(normalized);
+		if (workspace === void 0) throw new Error("selected DSH workspace is unavailable");
+		return workspace;
+	}
+	workspaceForPath(path) {
+		const normalized = path?.trim();
+		if (normalized === void 0 || normalized === "") return void 0;
+		const canonical = resolve(normalized);
+		return this.workspaceRegistry?.list().find((workspace) => resolve(workspace.path) === canonical);
+	}
 };
 //#endregion
 //#region lib/types/subagent.js
+function isAgentRuntimeSource$1(value) {
+	return typeof value === "object" && value !== null && "forAgent" in value && typeof value.forAgent === "function";
+}
 const READ_TOOLS = [
 	"mnemon_memory_bodies",
 	"mnemon_recall",
@@ -3679,7 +3771,7 @@ function isSubagent(agent) {
 /** Delegates memory judgment and execution to a fresh, tool-scoped DSH child. */
 var MnemonSubagentCoordinator = class {
 	subagents;
-	runtimeMemory;
+	runtimeMemoryOrSource;
 	documents;
 	counters = {
 		recalls: 0,
@@ -3693,25 +3785,22 @@ var MnemonSubagentCoordinator = class {
 	};
 	runtimeQueue = Promise.resolve();
 	documentQueue = Promise.resolve();
-	constructor(subagents, runtimeMemory, documents) {
+	constructor(subagents, runtimeMemoryOrSource, documents) {
 		this.subagents = subagents;
-		this.runtimeMemory = runtimeMemory;
+		this.runtimeMemoryOrSource = runtimeMemoryOrSource;
 		this.documents = documents;
 	}
 	snapshot() {
 		return { ...this.counters };
 	}
 	documentsSnapshot(parent) {
-		if (this.documents === void 0) throw new Error("Mnemon Documents control plane is unavailable");
-		return this.documents.forAgent(parent).snapshot();
+		return this.documentsFor(parent).forAgent(parent).snapshot();
 	}
 	documentGet(parent, id) {
-		if (this.documents === void 0) throw new Error("Mnemon Documents control plane is unavailable");
-		return this.documents.forAgent(parent).get(id);
+		return this.documentsFor(parent).forAgent(parent).get(id);
 	}
 	documentSearch(parent, query, includeArchived = false, limit) {
-		if (this.documents === void 0) throw new Error("Mnemon Documents control plane is unavailable");
-		return this.documents.forAgent(parent).search(query, {
+		return this.documentsFor(parent).forAgent(parent).search(query, {
 			includeArchived,
 			...limit === void 0 ? {} : { limit }
 		});
@@ -3811,8 +3900,7 @@ ${naturalRequest(request)}`;
 		};
 	}
 	async documentLocked(parent, request, signal) {
-		if (this.documents === void 0) throw new Error("Mnemon Documents control plane is unavailable");
-		const controller = this.documents.forAgent(parent);
+		const controller = this.documentsFor(parent).forAgent(parent);
 		const archivedDocumentIds = [];
 		const memoryBodyIds = /* @__PURE__ */ new Set();
 		let lastArchive;
@@ -3848,8 +3936,7 @@ ${naturalRequest(request)}`;
 		};
 	}
 	async archiveDocumentLocked(parent, id, signal) {
-		if (this.documents === void 0) throw new Error("Mnemon Documents control plane is unavailable");
-		const controller = this.documents.forAgent(parent);
+		const controller = this.documentsFor(parent).forAgent(parent);
 		const document = controller.get(id);
 		if (document.status !== "active") throw new Error("only active documents can be archived");
 		const { provider, runId, result } = await this.delegate(parent, "document-archive", "Archive managed document", "Archive this managed document now.", DOCUMENT_ARCHIVE_TOOLS, DOCUMENT_ARCHIVE_SCHEMA, signal, "spawn", documentArchivePersona(document));
@@ -3872,14 +3959,14 @@ ${naturalRequest(request)}`;
 		};
 	}
 	async runtimeLocked(parent, request, signal) {
-		if (this.runtimeMemory === void 0) throw new Error("runtime memory control plane is unavailable");
+		const runtimeMemory = this.runtimeMemoryFor(parent);
 		try {
-			return await this.runtimeMemory.mutate(request);
+			return await runtimeMemory.mutate(request);
 		} catch (error) {
 			if (!(error instanceof RuntimeMemoryCapacityError) || request.action !== "add") throw error;
 		}
 		if (request.target === "user") return this.compactUserAndRetry(parent, request, signal);
-		const snapshot = this.runtimeMemory.snapshot();
+		const snapshot = runtimeMemory.snapshot();
 		const targetView = snapshot.targets[request.target];
 		const targetEntries = snapshot.entries.filter((entry) => entry.target === request.target);
 		if (targetEntries.length === 0) throw new Error("runtime memory capacity was exceeded without entries available for archival");
@@ -3906,9 +3993,9 @@ ${indentedText(request.content ?? "")}`;
 				importance: item.importance
 			};
 		}) : [];
-		await this.runtimeMemory.compactTarget(snapshot.revision, request.target, compactedEntries, compactedBudget);
+		await runtimeMemory.compactTarget(snapshot.revision, request.target, compactedEntries, compactedBudget);
 		return {
-			...await this.runtimeMemory.mutate(request),
+			...await runtimeMemory.mutate(request),
 			maintenance: {
 				kind: "mnemon-archive",
 				runId,
@@ -3919,8 +4006,8 @@ ${indentedText(request.content ?? "")}`;
 		};
 	}
 	async compactUserAndRetry(parent, request, signal) {
-		if (this.runtimeMemory === void 0) throw new Error("runtime memory control plane is unavailable");
-		const snapshot = this.runtimeMemory.snapshot();
+		const runtimeMemory = this.runtimeMemoryFor(parent);
+		const snapshot = runtimeMemory.snapshot();
 		const targetEntries = snapshot.entries.filter((entry) => entry.target === "user");
 		if (targetEntries.length === 0) throw new Error("USER.md capacity was exceeded without entries available for compaction");
 		const targetView = snapshot.targets.user;
@@ -3973,9 +4060,9 @@ ${indentedText(request.content ?? "")}`;
 		}));
 		const candidateBytes = Buffer.byteLength(candidates.map((entry) => entry.content.trim().replace(/\s+/gu, " ")).join(RUNTIME_ENTRY_DELIMITER), "utf8");
 		if (candidateBytes > compactedBudget) throw new Error(`USER.md compaction did not fit the host budget (${candidateBytes} > ${compactedBudget} bytes)`);
-		await this.runtimeMemory.compactTarget(snapshot.revision, "user", candidates, compactedBudget);
+		await runtimeMemory.compactTarget(snapshot.revision, "user", candidates, compactedBudget);
 		return {
-			...await this.runtimeMemory.mutate(request),
+			...await runtimeMemory.mutate(request),
 			maintenance: {
 				kind: "local-compaction",
 				runId,
@@ -4043,6 +4130,16 @@ ${indentedText(request.content ?? "")}`;
 		if (selected === void 0) throw new Error("dsh-mnemon requires a DSH subagent provider with structured output, tool filtering, persona, and depth limiting");
 		return selected;
 	}
+	runtimeMemoryFor(parent) {
+		if (isAgentRuntimeSource$1(this.runtimeMemoryOrSource)) return this.runtimeMemoryOrSource.forAgent(parent).runtimeMemory;
+		if (this.runtimeMemoryOrSource === void 0) throw new Error("runtime memory control plane is unavailable");
+		return this.runtimeMemoryOrSource;
+	}
+	documentsFor(parent) {
+		if (isAgentRuntimeSource$1(this.runtimeMemoryOrSource)) return this.runtimeMemoryOrSource.forAgent(parent).documents;
+		if (this.documents === void 0) throw new Error("Mnemon Documents control plane is unavailable");
+		return this.documents;
+	}
 };
 //#endregion
 //#region lib/types/review-activity.js
@@ -4213,13 +4310,13 @@ function completedToolActivity(events, turn) {
 		names: new Set(events.filter((event) => event.type === "tool/call" && eventTurn(event) === turn && typeof event.data.name === "string").map((event) => String(event.data.name)))
 	};
 }
-/** Join the text blocks of an `assistant/message` event whose message id matches. */
+/** Join the text content of an `assistant/message` event whose message id matches. */
 function assistantMessageText(events, messageId) {
 	for (const event of events) {
 		if (event.type !== "assistant/message") continue;
 		const message = event.data.message;
 		if (message === void 0 || typeof message !== "object" || message.id !== messageId) continue;
-		const text = (Array.isArray(message.blocks) ? message.blocks : []).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join("\n\n").trim();
+		const text = (Array.isArray(message.content) ? message.content : []).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join("\n\n").trim();
 		return text === "" ? null : {
 			messageId,
 			text
@@ -4436,6 +4533,7 @@ var MnemonLifecycle = class {
 	ctx;
 	coordinator;
 	config;
+	runtimeSource;
 	owners = /* @__PURE__ */ new Map();
 	counters = {
 		primes: 0,
@@ -4446,10 +4544,11 @@ var MnemonLifecycle = class {
 	};
 	/** Bounded process-local replay fence for finalized-message write actions. */
 	supervisedWritebacks = /* @__PURE__ */ new Map();
-	constructor(ctx, coordinator, config) {
+	constructor(ctx, coordinator, config, runtimeSource) {
 		this.ctx = ctx;
 		this.coordinator = coordinator;
 		this.config = config;
+		this.runtimeSource = runtimeSource;
 	}
 	start() {
 		const stopCreated = this.ctx.on("agent/created", (({ agent }) => {
@@ -4585,7 +4684,9 @@ var MnemonLifecycle = class {
 		let dispose;
 		dispose = agent.ctx.effect(() => {
 			const stop = lifecycle.start();
+			const stopRuntimeContext = this.runtimeSource === void 0 ? () => {} : registerAgentRuntimeMemoryContext(agent, () => this.runtimeSource.forAgent(agent).runtimeMemory);
 			return () => {
+				stopRuntimeContext();
 				stop();
 				if (this.owners.get(agent)?.dispose === dispose) this.owners.delete(agent);
 			};
@@ -4597,10 +4698,427 @@ var MnemonLifecycle = class {
 	}
 };
 //#endregion
-//#region lib/types/rpc.js
+//#region lib/types/version-updates.js
+const DSH_MNEMON_PACKAGE = "dsh-mnemon";
+const MNEMON_MODULE = "github.com/mnemon-dev/mnemon";
+const PACKAGE_MANIFEST_PATH = fileURLToPath(new URL("../package.json", import.meta.url));
+const CHECK_TIMEOUT_MS = 1e4;
+const UPDATE_TIMEOUT_MS = 6e5;
+const MAX_UPDATE_OUTPUT_BYTES = 16384;
+async function settledWithin(promise, fallback, timeoutMs = 11e3) {
+	let timer;
+	try {
+		return await Promise.race([promise.catch(() => fallback), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(fallback), timeoutMs);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+function manifest(path) {
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function executable(path) {
+	try {
+		accessSync(path, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Resolve one executable without invoking a shell. */
+function resolveExecutable(command) {
+	if (command.includes("/") || command.includes("\\")) {
+		const path = command.startsWith("~/") ? join(homedir(), command.slice(2)) : resolve(command);
+		return executable(path) ? path : void 0;
+	}
+	const names = process.platform === "win32" ? [
+		`${command}.exe`,
+		`${command}.cmd`,
+		command
+	] : [command];
+	for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+		if (directory === "") continue;
+		for (const name of names) {
+			const path = join(directory, name);
+			if (executable(path)) return path;
+		}
+	}
+}
+function parseSemver(value) {
+	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value.trim());
+	if (match === null) return void 0;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		prerelease: match[4] === void 0 ? [] : match[4].split(".")
+	};
+}
+function compareVersions(a, b) {
+	const left = parseSemver(a);
+	const right = parseSemver(b);
+	if (left === void 0 && right === void 0) return 0;
+	if (left === void 0) return -1;
+	if (right === void 0) return 1;
+	for (const field of [
+		"major",
+		"minor",
+		"patch"
+	]) if (left[field] !== right[field]) return left[field] < right[field] ? -1 : 1;
+	if (left.prerelease.length === 0 && right.prerelease.length === 0) return 0;
+	if (left.prerelease.length === 0) return 1;
+	if (right.prerelease.length === 0) return -1;
+	for (let index = 0; index < Math.max(left.prerelease.length, right.prerelease.length); index++) {
+		const aPart = left.prerelease[index];
+		const bPart = right.prerelease[index];
+		if (aPart === void 0) return -1;
+		if (bPart === void 0) return 1;
+		if (aPart === bPart) continue;
+		const aNumber = /^\d+$/.test(aPart);
+		const bNumber = /^\d+$/.test(bPart);
+		if (aNumber && bNumber) return Number(aPart) < Number(bPart) ? -1 : 1;
+		if (aNumber) return -1;
+		if (bNumber) return 1;
+		return aPart < bPart ? -1 : 1;
+	}
+	return 0;
+}
+function versionFrom(text) {
+	return text.match(/\bv?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)\b/)?.[1];
+}
+async function fetchJson(url) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => {
+		controller.abort();
+	}, CHECK_TIMEOUT_MS);
+	try {
+		const response = await fetch(url, {
+			signal: controller.signal,
+			headers: {
+				accept: "application/json",
+				"user-agent": "dsh-mnemon-version-check"
+			}
+		});
+		if (!response.ok) return void 0;
+		return await response.json();
+	} catch {
+		return;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function fetchNpmLatest(name) {
+	const body = await fetchJson(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`);
+	if (typeof body !== "object" || body === null) return void 0;
+	const version = body.version;
+	return typeof version === "string" ? version : void 0;
+}
+async function fetchMnemonLatest() {
+	const body = await fetchJson("https://api.github.com/repos/mnemon-dev/mnemon/releases/latest");
+	if (typeof body !== "object" || body === null) return void 0;
+	const tag = body.tag_name;
+	return typeof tag === "string" ? tag.replace(/^v/, "") : void 0;
+}
+function dependencySpec(profile) {
+	return profile?.dependencies?.[DSH_MNEMON_PACKAGE] ?? profile?.devDependencies?.[DSH_MNEMON_PACKAGE];
+}
+function isLinkSpec(spec) {
+	return spec !== void 0 && /^(?:link|file|workspace):|^\.{1,2}(?:[/\\]|$)/.test(spec);
+}
+function linkedTarget(profileDir, spec) {
+	const value = spec.replace(/^(?:link|file):/, "");
+	if (value.startsWith("workspace:")) return void 0;
+	return isAbsolute(value) ? resolve(value) : resolve(profileDir, value);
+}
+function profileFromAncestor(packageManifestPath) {
+	let directory = dirname(packageManifestPath);
+	for (let depth = 0; depth < 12; depth++) {
+		const profile = manifest(join(directory, "package.json"));
+		if (profile?.name?.startsWith("dsh-profile-") === true) return {
+			mode: isLinkSpec(dependencySpec(profile)) ? "link" : "npm",
+			profileName: profile.name.slice(12),
+			profileDir: directory
+		};
+		const parent = dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+}
+function linkedProfile(packageManifestPath, dshHome) {
+	const profilesDir = join(dshHome, "profiles");
+	if (!existsSync(profilesDir)) return void 0;
+	const packageRoot = realpathSync(dirname(packageManifestPath));
+	const matches = [];
+	for (const entry of readdirSync(profilesDir, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		const profileDir = join(profilesDir, entry.name);
+		const spec = dependencySpec(manifest(join(profileDir, "package.json")));
+		if (!isLinkSpec(spec)) continue;
+		const target = spec === void 0 ? void 0 : linkedTarget(profileDir, spec);
+		if (target === void 0 || !existsSync(target)) continue;
+		try {
+			if (realpathSync(target) === packageRoot) matches.push({
+				name: entry.name,
+				dir: profileDir
+			});
+		} catch {}
+	}
+	const match = matches[0];
+	return match === void 0 ? void 0 : {
+		mode: "link",
+		profileName: match.name,
+		profileDir: match.dir
+	};
+}
+function inspectDshInstall(packageManifestPath, dshHome) {
+	return profileFromAncestor(packageManifestPath) ?? linkedProfile(packageManifestPath, dshHome) ?? { mode: "manual" };
+}
+async function resultOrThrow(runner, command, args, timeoutMs) {
+	const result = await runner(command, args, {
+		timeoutMs,
+		maxOutputBytes: MAX_UPDATE_OUTPUT_BYTES
+	});
+	if (result.exitCode !== 0) {
+		const detail = result.stderr.trim() || result.stdout.trim() || `exit ${String(result.exitCode)}`;
+		throw new Error(detail);
+	}
+	return result;
+}
+function updateOutput(result) {
+	const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n").trim();
+	return output === "" ? void 0 : output.slice(-4e3);
+}
+var VersionUpdateManager = class {
+	dshMnemonVersion;
+	packageManifestPath;
+	dshHome;
+	mnemonCliPath;
+	processRunner;
+	executable;
+	fetchNpmLatest;
+	fetchMnemonLatest;
+	constructor(dependencies = {}) {
+		this.packageManifestPath = dependencies.packageManifestPath ?? PACKAGE_MANIFEST_PATH;
+		this.dshMnemonVersion = manifest(this.packageManifestPath)?.version ?? "0.0.0";
+		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 ?? fetchMnemonLatest;
+	}
+	get currentDshMnemonVersion() {
+		return this.dshMnemonVersion;
+	}
+	async inspectMnemon() {
+		const configured = this.mnemonCliPath() ?? findMnemonCommand({});
+		const command = configured === void 0 ? void 0 : this.executable(configured);
+		if (command === void 0) return { install: { mode: "missing" } };
+		let current;
+		try {
+			current = versionFrom((await resultOrThrow(this.processRunner, command, ["--version"], CHECK_TIMEOUT_MS)).stdout);
+		} catch {
+			return { install: {
+				mode: "manual",
+				command
+			} };
+		}
+		let realCommand = command;
+		try {
+			realCommand = realpathSync(command);
+		} catch {}
+		if (realCommand.includes("/Caskroom/mnemon/")) {
+			const brew = this.executable("brew");
+			return {
+				...current === void 0 ? {} : { current },
+				install: {
+					mode: "homebrew",
+					command,
+					...brew === void 0 ? {} : {
+						updateCommand: brew,
+						updateArgs: [
+							"upgrade",
+							"--cask",
+							"mnemon"
+						]
+					}
+				}
+			};
+		}
+		if (realCommand.includes("/Cellar/mnemon/")) {
+			const brew = this.executable("brew");
+			return {
+				...current === void 0 ? {} : { current },
+				install: {
+					mode: "homebrew",
+					command,
+					...brew === void 0 ? {} : {
+						updateCommand: brew,
+						updateArgs: ["upgrade", "mnemon-dev/tap/mnemon"]
+					}
+				}
+			};
+		}
+		const go = this.executable("go");
+		if (go !== void 0) try {
+			if ((await resultOrThrow(this.processRunner, go, [
+				"version",
+				"-m",
+				command
+			], CHECK_TIMEOUT_MS)).stdout.includes(MNEMON_MODULE)) return {
+				...current === void 0 ? {} : { current },
+				install: {
+					mode: "go",
+					command,
+					updateCommand: go,
+					updateArgs: ["install", `${MNEMON_MODULE}@latest`]
+				}
+			};
+		} catch {}
+		return {
+			...current === void 0 ? {} : { current },
+			install: {
+				mode: "manual",
+				command
+			}
+		};
+	}
+	async check() {
+		const [mnemonLocal, mnemonLatest, dshLatest] = await Promise.all([
+			settledWithin(this.inspectMnemon(), { install: { mode: "missing" } }),
+			settledWithin(this.fetchMnemonLatest(), void 0),
+			settledWithin(this.fetchNpmLatest(DSH_MNEMON_PACKAGE), void 0)
+		]);
+		const dshInstall = inspectDshInstall(this.packageManifestPath, this.dshHome);
+		const pnpm = this.executable("pnpm");
+		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 mnemonSupported = mnemonLocal.install.updateCommand !== void 0;
+		const dshSupported = dshInstall.mode === "npm" && dshInstall.profileDir !== void 0 && pnpm !== void 0;
+		return {
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			components: [{
+				id: "mnemon",
+				name: "Mnemon CLI",
+				...mnemonLocal.current === void 0 ? {} : { current: mnemonLocal.current },
+				...mnemonLatest === void 0 ? {} : { latest: mnemonLatest },
+				outdated: mnemonOutdated,
+				installMode: mnemonLocal.install.mode,
+				updateSupported: mnemonSupported,
+				updateHint: mnemonLocal.install.mode === "homebrew" ? mnemonSupported ? "brew" : "brew-missing" : mnemonLocal.install.mode === "go" ? "go" : mnemonLocal.install.mode === "missing" ? "install" : "manual",
+				...mnemonLatest === void 0 ? { checkError: "latest-unavailable" } : {}
+			}, {
+				id: "dsh-mnemon",
+				name: "dsh-mnemon",
+				current: this.currentDshMnemonVersion,
+				...dshLatest === void 0 ? {} : { latest: dshLatest },
+				outdated: dshOutdated,
+				installMode: dshInstall.mode,
+				updateSupported: dshSupported,
+				updateHint: dshInstall.mode === "npm" ? dshSupported ? "pnpm" : "pnpm-missing" : dshInstall.mode === "link" ? "link" : "manual",
+				...dshLatest === void 0 ? { checkError: "latest-unavailable" } : {}
+			}]
+		};
+	}
+	async update(component) {
+		if (component === "mnemon") {
+			const before = await this.inspectMnemon();
+			const latest = await this.fetchMnemonLatest();
+			if (before.current === void 0) throw new Error("Mnemon CLI is unavailable");
+			if (latest === void 0) throw new Error("Unable to verify the latest Mnemon release");
+			if (compareVersions(before.current, latest) >= 0) return {
+				component,
+				previousVersion: before.current,
+				currentVersion: before.current,
+				updated: false,
+				restartRequired: false
+			};
+			if (before.install.updateCommand === void 0 || before.install.updateArgs === void 0) throw new Error("This Mnemon installation cannot be updated automatically");
+			const output = await resultOrThrow(this.processRunner, before.install.updateCommand, before.install.updateArgs, UPDATE_TIMEOUT_MS);
+			const after = await this.inspectMnemon();
+			const outputText = updateOutput(output);
+			return {
+				component,
+				previousVersion: before.current,
+				currentVersion: after.current ?? latest,
+				updated: true,
+				restartRequired: false,
+				...outputText === void 0 ? {} : { output: outputText }
+			};
+		}
+		if (component !== "dsh-mnemon") throw new Error(`Unknown version component: ${String(component)}`);
+		const latest = await this.fetchNpmLatest(DSH_MNEMON_PACKAGE);
+		if (latest === void 0) throw new Error("Unable to verify the latest dsh-mnemon release");
+		if (compareVersions(this.currentDshMnemonVersion, latest) >= 0) return {
+			component,
+			previousVersion: this.currentDshMnemonVersion,
+			currentVersion: this.currentDshMnemonVersion,
+			updated: false,
+			restartRequired: false
+		};
+		const install = inspectDshInstall(this.packageManifestPath, this.dshHome);
+		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 outputText = updateOutput(await resultOrThrow(this.processRunner, pnpm, ["update", DSH_MNEMON_PACKAGE], UPDATE_TIMEOUT_MS));
+		this.dshMnemonVersion = latest;
+		return {
+			component,
+			previousVersion: this.currentDshMnemonVersion,
+			currentVersion: latest,
+			updated: true,
+			restartRequired: true,
+			...outputText === void 0 ? {} : { output: outputText }
+		};
+	}
+};
+//#endregion
+//#region lib/types/channels.js
 const MNEMON_READ_CHANNEL = "/dsh-mnemon-read";
 const MNEMON_WRITE_CHANNEL = "/dsh-mnemon-write";
 const MNEMON_PACK_CHANNEL = "/dsh-mnemon-pack";
+//#endregion
+//#region lib/types/rpc.js
+function isRoutedRuntime(value) {
+	return "route" in value && typeof value.route === "function";
+}
+function requestedScope(payload) {
+	const workspaceId = payload.workspaceId === void 0 ? void 0 : String(payload.workspaceId).trim();
+	const sessionId = payload.sessionId === void 0 ? void 0 : String(payload.sessionId).trim();
+	return {
+		...workspaceId === void 0 || workspaceId === "" ? {} : { workspaceId },
+		...sessionId === void 0 || sessionId === "" ? {} : { sessionId }
+	};
+}
+function runtimeFor(input, payload, runtimeMemory, storage) {
+	if (isRoutedRuntime(input)) {
+		const scope = requestedScope(payload);
+		const route = input.route(scope);
+		return {
+			graph: route.graph,
+			route,
+			explicitWorkspace: scope.workspaceId !== void 0 && route.graph.config.storageScope === "workspace"
+		};
+	}
+	return {
+		graph: {
+			service: input,
+			runtimeMemory,
+			documents: void 0,
+			storage,
+			packs: void 0
+		},
+		explicitWorkspace: false
+	};
+}
+function requireAligned(route) {
+	if (route?.aligned === false) throw new Error("the selected memory workspace differs from the current session; align the workbench before running an Agent-backed operation");
+}
 function object$1(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("payload must be an object");
 	return value;
@@ -4631,34 +5149,60 @@ function badRequest$1(message) {
 		}
 	};
 }
-function createReadHandler(service, lifecycle, runtimeMemory, storage) {
+function createReadHandler(input, lifecycle, runtimeMemory, storage, versions) {
 	return async (endpoint, rawPayload) => {
 		try {
 			const payload = object$1(rawPayload);
+			if (endpoint === "versions") {
+				if (versions === void 0) throw new Error("version checks are unavailable");
+				return success$1(await versions.check());
+			}
+			const resolved = runtimeFor(input, payload, runtimeMemory, storage);
+			const { service } = resolved.graph;
+			const selectedWorkspace = resolved.route?.selectedWorkspace;
+			const documentController = resolved.explicitWorkspace && selectedWorkspace !== void 0 ? resolved.graph.documents.forWorkspace(selectedWorkspace.path) : void 0;
 			switch (endpoint) {
 				case "runtime-memory":
-					if (runtimeMemory === void 0) throw new Error("runtime memory is unavailable");
-					return success$1(runtimeMemory.snapshot());
+					if (resolved.graph.runtimeMemory === void 0) throw new Error("runtime memory is unavailable");
+					return success$1(resolved.graph.runtimeMemory.snapshot());
 				case "status": {
 					const sessionId = payload.sessionId === void 0 ? "" : String(payload.sessionId).trim();
 					let documents;
-					if (lifecycle !== void 0 && sessionId !== "") try {
+					if (documentController !== void 0) try {
+						documents = documentController.snapshot();
+					} catch {}
+					else if (lifecycle !== void 0 && sessionId !== "") try {
 						documents = lifecycle.documents(sessionId);
 					} catch {}
 					return success$1({
 						...await service.status(),
+						...versions === void 0 ? {} : { dshMnemonVersion: versions.currentDshMnemonVersion },
 						...lifecycle === void 0 ? {} : { lifecycle: lifecycle.snapshot(payload.sessionId === void 0 ? void 0 : String(payload.sessionId)) },
 						...documents === void 0 ? {} : { documents },
-						...storage === void 0 ? {} : { storage: storage.catalog(lifecycle?.workspaceRoot(sessionId)) }
+						...resolved.graph.storage === void 0 ? {} : { storage: resolved.graph.storage.catalog(selectedWorkspace?.path ?? lifecycle?.workspaceRoot(sessionId)) },
+						...resolved.route === void 0 ? {} : { workspaceContext: {
+							mode: service.config.storageScope,
+							selectedRoot: resolved.route.selectedRoot,
+							effectiveRoot: resolved.route.effectiveRoot,
+							aligned: resolved.route.aligned,
+							...resolved.route.selectedWorkspace === void 0 ? {} : { selectedWorkspace: resolved.route.selectedWorkspace },
+							...resolved.route.effectiveWorkspace === void 0 ? {} : { effectiveWorkspace: resolved.route.effectiveWorkspace }
+						} }
 					});
 				}
 				case "documents":
+					if (documentController !== void 0) return success$1(documentController.snapshot());
 					if (lifecycle === void 0) throw new Error("Mnemon Documents require lifecycle integration");
 					return success$1(lifecycle.documents(String(payload.sessionId ?? "")));
 				case "document":
+					if (documentController !== void 0) return success$1(documentController.get(String(payload.id ?? "")));
 					if (lifecycle === void 0) throw new Error("Mnemon Documents require lifecycle integration");
 					return success$1(lifecycle.document(String(payload.sessionId ?? ""), String(payload.id ?? "")));
 				case "document-search":
+					if (documentController !== void 0) return success$1(await documentController.search(String(payload.query ?? ""), {
+						includeArchived: payload.includeArchived === true,
+						...payload.limit === void 0 ? {} : { limit: Number(payload.limit) }
+					}));
 					if (lifecycle === void 0) throw new Error("Mnemon Documents require lifecycle integration");
 					return success$1(await lifecycle.searchDocuments(String(payload.sessionId ?? ""), String(payload.query ?? ""), payload.includeArchived === true, payload.limit === void 0 ? void 0 : Number(payload.limit)));
 				case "graph": return success$1(await service.graph(void 0, Array.isArray(payload.memoryBodyIds) ? payload.memoryBodyIds.map(String) : void 0));
@@ -4721,14 +5265,26 @@ function createReadHandler(service, lifecycle, runtimeMemory, storage) {
 		}
 	};
 }
-function createWriteHandler(service, lifecycle, runtimeMemory) {
+function createWriteHandler(input, lifecycle, runtimeMemory, versions) {
 	return async (endpoint, rawPayload) => {
 		try {
-			if (!service.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
 			const payload = object$1(rawPayload);
+			if (endpoint === "version-update") {
+				if (versions === void 0) throw new Error("version updates are unavailable");
+				const component = String(payload.component ?? "");
+				if (component !== "mnemon" && component !== "dsh-mnemon") return badRequest$1(`unknown version component: ${component}`);
+				return success$1(await versions.update(component));
+			}
+			const resolved = runtimeFor(input, payload, runtimeMemory);
+			const { service } = resolved.graph;
+			if (!service.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
+			const selectedWorkspace = resolved.route?.selectedWorkspace;
+			const documentController = resolved.explicitWorkspace && selectedWorkspace !== void 0 ? resolved.graph.documents.forWorkspace(selectedWorkspace.path) : void 0;
+			const inspectionDiverged = resolved.explicitWorkspace && resolved.route?.aligned === false;
+			const alignedSession = resolved.explicitWorkspace && resolved.route?.aligned === true && resolved.route.effectiveWorkspace !== void 0;
 			switch (endpoint) {
 				case "runtime-memory":
-					if (runtimeMemory === void 0) throw new Error("runtime memory is unavailable");
+					if (resolved.graph.runtimeMemory === void 0) throw new Error("runtime memory is unavailable");
 					{
 						const request = {
 							action: String(payload.action ?? ""),
@@ -4738,36 +5294,57 @@ function createWriteHandler(service, lifecycle, runtimeMemory) {
 							...payload.importance === void 0 ? {} : { importance: String(payload.importance) }
 						};
 						const sessionId = String(payload.sessionId ?? "").trim();
-						return success$1(lifecycle === void 0 || sessionId === "" ? await runtimeMemory.mutate(request) : await lifecycle.runtime(sessionId, request));
+						return success$1(inspectionDiverged || lifecycle === void 0 || sessionId === "" || resolved.explicitWorkspace && !alignedSession ? await resolved.graph.runtimeMemory.mutate(request) : await lifecycle.runtime(sessionId, request));
 					}
 				case "supervise":
 					if (lifecycle === void 0) throw new Error("Mnemon lifecycle integration is unavailable");
+					requireAligned(resolved.route);
 					return success$1(await lifecycle.supervise(String(payload.sessionId ?? ""), String(payload.content ?? ""), payload.idempotencyKey === void 0 ? void 0 : String(payload.idempotencyKey)));
-				case "document":
-					if (lifecycle === void 0) throw new Error("Mnemon Documents require lifecycle integration");
-					{
-						const action = String(payload.action ?? "");
-						const sessionId = String(payload.sessionId ?? "");
-						if (action === "archive") return success$1(await lifecycle.archiveDocument(sessionId, String(payload.id ?? "")));
-						if (action === "create") return success$1(await lifecycle.mutateDocument(sessionId, {
+				case "document": {
+					const action = String(payload.action ?? "");
+					const sessionId = String(payload.sessionId ?? "");
+					if (documentController !== void 0 && action !== "archive" && (!alignedSession || lifecycle === void 0)) {
+						const sessionIds = resolved.route?.aligned === true && sessionId.trim() !== "" ? [sessionId] : [];
+						if (action === "create") return success$1(await documentController.mutate({
 							action: "create",
 							title: String(payload.title ?? ""),
 							content: String(payload.content ?? ""),
 							...payload.description === void 0 ? {} : { description: String(payload.description) },
 							...Array.isArray(payload.sourcePaths) ? { sourcePaths: payload.sourcePaths.map(String) } : {},
-							sessionIds: [sessionId]
+							sessionIds
 						}));
-						if (action === "update") return success$1(await lifecycle.mutateDocument(sessionId, {
+						if (action === "update") return success$1(await documentController.mutate({
 							action: "update",
 							id: String(payload.id ?? ""),
 							...payload.title === void 0 ? {} : { title: String(payload.title) },
 							...payload.description === void 0 ? {} : { description: String(payload.description) },
 							...payload.content === void 0 ? {} : { content: String(payload.content) },
 							...Array.isArray(payload.sourcePaths) ? { sourcePaths: payload.sourcePaths.map(String) } : {},
-							sessionIds: [sessionId]
+							sessionIds
 						}));
-						return badRequest$1(`unknown document action: ${action}`);
 					}
+					if (lifecycle === void 0) throw new Error("Mnemon Documents require lifecycle integration");
+					if (resolved.explicitWorkspace) requireAligned(resolved.route);
+					if (action === "archive") return success$1(await lifecycle.archiveDocument(sessionId, String(payload.id ?? "")));
+					if (action === "create") return success$1(await lifecycle.mutateDocument(sessionId, {
+						action: "create",
+						title: String(payload.title ?? ""),
+						content: String(payload.content ?? ""),
+						...payload.description === void 0 ? {} : { description: String(payload.description) },
+						...Array.isArray(payload.sourcePaths) ? { sourcePaths: payload.sourcePaths.map(String) } : {},
+						sessionIds: [sessionId]
+					}));
+					if (action === "update") return success$1(await lifecycle.mutateDocument(sessionId, {
+						action: "update",
+						id: String(payload.id ?? ""),
+						...payload.title === void 0 ? {} : { title: String(payload.title) },
+						...payload.description === void 0 ? {} : { description: String(payload.description) },
+						...payload.content === void 0 ? {} : { content: String(payload.content) },
+						...Array.isArray(payload.sourcePaths) ? { sourcePaths: payload.sourcePaths.map(String) } : {},
+						sessionIds: [sessionId]
+					}));
+					return badRequest$1(`unknown document action: ${action}`);
+				}
 				case "remember": {
 					const request = {
 						content: String(payload.content ?? ""),
@@ -4778,10 +5355,10 @@ function createWriteHandler(service, lifecycle, runtimeMemory) {
 						...payload.memoryBodyId === void 0 ? {} : { memoryBodyId: String(payload.memoryBodyId) },
 						source: "user"
 					};
-					return success$1(lifecycle === void 0 ? await service.remember(request) : await lifecycle.remember(String(payload.sessionId ?? ""), request));
+					return success$1(inspectionDiverged || lifecycle === void 0 || resolved.explicitWorkspace && !alignedSession ? await service.remember(request) : await lifecycle.remember(String(payload.sessionId ?? ""), request));
 				}
-				case "link": return success$1(lifecycle === void 0 ? await service.link(String(payload.sourceId ?? ""), String(payload.targetId ?? ""), payload.type, payload.weight === void 0 ? .5 : Number(payload.weight), payload.reason === void 0 ? void 0 : String(payload.reason), void 0, payload.memoryBodyId === void 0 ? void 0 : String(payload.memoryBodyId)) : await lifecycle.mutate(String(payload.sessionId ?? ""), "link", payload));
-				case "forget": return success$1(lifecycle === void 0 ? await service.forget(String(payload.id ?? ""), void 0, payload.memoryBodyId === void 0 ? void 0 : String(payload.memoryBodyId)) : await lifecycle.mutate(String(payload.sessionId ?? ""), "forget", {
+				case "link": return success$1(inspectionDiverged || lifecycle === void 0 || resolved.explicitWorkspace && !alignedSession ? await service.link(String(payload.sourceId ?? ""), String(payload.targetId ?? ""), payload.type, payload.weight === void 0 ? .5 : Number(payload.weight), payload.reason === void 0 ? void 0 : String(payload.reason), void 0, payload.memoryBodyId === void 0 ? void 0 : String(payload.memoryBodyId)) : await lifecycle.mutate(String(payload.sessionId ?? ""), "link", payload));
+				case "forget": return success$1(inspectionDiverged || lifecycle === void 0 || resolved.explicitWorkspace && !alignedSession ? await service.forget(String(payload.id ?? ""), void 0, payload.memoryBodyId === void 0 ? void 0 : String(payload.memoryBodyId)) : await lifecycle.mutate(String(payload.sessionId ?? ""), "forget", {
 					id: String(payload.id ?? ""),
 					...payload.memoryBodyId === void 0 ? {} : { memoryBodyId: String(payload.memoryBodyId) }
 				}));
@@ -4795,6 +5372,7 @@ function createWriteHandler(service, lifecycle, runtimeMemory) {
 					...payload.description === void 0 ? {} : { description: String(payload.description) },
 					...payload.active === void 0 ? {} : { active: Boolean(payload.active) }
 				}));
+				case "body-delete": return success$1(await service.deleteBody(String(payload.memoryBodyId ?? "")));
 				default: return badRequest$1(`unknown write endpoint: ${endpoint}`);
 			}
 		} catch (error) {
@@ -4821,10 +5399,16 @@ function createPackHandler(manager, writeEnabled = true) {
 	};
 }
 /** Read operations are available to trusted Web hosts; local mutations stay loopback-only. */
-function registerRpc(connection, service, lifecycle, runtimeMemory, storage, packs) {
-	connection.rpc.handle(MNEMON_READ_CHANNEL, createReadHandler(service, lifecycle, runtimeMemory, storage), { authority: "trusted-host" });
-	connection.rpc.handle(MNEMON_WRITE_CHANNEL, createWriteHandler(service, lifecycle, runtimeMemory), { authority: "loopback" });
-	if (packs !== void 0) connection.rpc.handle(MNEMON_PACK_CHANNEL, createPackHandler(packs, () => service.config.writeEnabled), { authority: "loopback" });
+function registerRpc(connection, input, lifecycle, runtimeMemory, storage, packs, versions) {
+	const versionManager = versions ?? new VersionUpdateManager({ mnemonCliPath: () => findVersionCli(input) });
+	connection.rpc.handle(MNEMON_READ_CHANNEL, createReadHandler(input, lifecycle, runtimeMemory, storage, versionManager), { authority: "trusted-host" });
+	connection.rpc.handle(MNEMON_WRITE_CHANNEL, createWriteHandler(input, lifecycle, runtimeMemory, versionManager), { authority: "loopback" });
+	const packManager = isRoutedRuntime(input) ? input.packs : packs;
+	const config = input.config;
+	if (packManager !== void 0) connection.rpc.handle(MNEMON_PACK_CHANNEL, createPackHandler(packManager, () => config.writeEnabled), { authority: "loopback" });
+}
+function findVersionCli(input) {
+	return input.config.cliPath;
 }
 //#endregion
 //#region lib/types/settings.js
@@ -4888,20 +5472,13 @@ const MUTABLE_FIELDS = [
 	"recallMode",
 	"writebackMode",
 	"idleReviewMs",
+	"displayMode",
 	"tabEnabled",
 	"writeEnabled"
 ];
 /** Nested paths of the live in-conversation interaction toggles. */
-const INTERACTION_PATHS = [
-	["conversationInteraction", "toolviews"],
-	["conversationInteraction", "turnBar"],
-	["conversationInteraction", "saveAction"]
-];
-const UI_FIELDS = [
-	"toolviews",
-	"turnBar",
-	"saveAction"
-];
+const INTERACTION_PATHS = [["conversationInteraction", "turnBar"], ["conversationInteraction", "saveAction"]];
+const UI_FIELDS = ["turnBar", "saveAction"];
 function namespaceOf(payload) {
 	const namespace = payload.namespace === void 0 ? MNEMON_SETTINGS_NAMESPACE : String(payload.namespace);
 	if (namespace !== "mnemon" && namespace !== "mnemon-ui") throw new Error(`unsupported Mnemon settings namespace: ${namespace}`);
@@ -4967,8 +5544,21 @@ function requireAgent(exec) {
 	if (exec.agent === void 0) throw new Error("Mnemon semantic operations require a live DSH agent");
 	return exec.agent;
 }
+function isAgentRuntimeSource(value) {
+	return "forAgent" in value && typeof value.forAgent === "function";
+}
 /** Root calls delegate to a bounded child; memory-worker calls reach the deterministic service. */
-function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
+function registerTools(ctx, serviceOrSource, coordinator, runtimeMemory, documents) {
+	const runtimeFor = (exec) => {
+		if (isAgentRuntimeSource(serviceOrSource)) return serviceOrSource.forAgent(requireAgent(exec));
+		if (runtimeMemory === void 0 || documents === void 0) throw new Error("Mnemon runtime control plane is unavailable");
+		return {
+			service: serviceOrSource,
+			runtimeMemory,
+			documents
+		};
+	};
+	const config = serviceOrSource.config;
 	ctx.tools.register(definition({
 		name: "mnemon_memory_bodies",
 		description: "List the global Mnemon Memory Space catalog, including each space id, name, description, activation state, database path, and statistics. Read only. Use this before choosing a write target, or when the Prime summary is insufficient. Recall may only read active spaces; writes may target any space.",
@@ -4980,7 +5570,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			schema: JSON_OBJECT_OUTPUT,
 			render: (_args, value) => text(value)
 		},
-		execute: (_args, exec) => service.bodies(exec.signal),
+		execute: (_args, exec) => runtimeFor(exec).service.bodies(exec.signal),
 		presentCall: () => ({
 			card: "generic",
 			title: "Inspect Mnemon Memory Spaces",
@@ -5039,7 +5629,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			render: (_args, value) => text(value)
 		},
 		async execute(args, exec) {
-			return isSubagent(exec.agent) ? service.search(args, exec.signal) : coordinator.recall(requireAgent(exec), args, exec.signal);
+			return isSubagent(exec.agent) ? runtimeFor(exec).service.search(args, exec.signal) : coordinator.recall(requireAgent(exec), args, exec.signal);
 		},
 		presentCall: (args) => ({
 			card: "generic",
@@ -5083,7 +5673,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 		},
 		async execute(args, exec) {
 			if (!isSubagent(exec.agent)) return coordinator.related(requireAgent(exec), args.id, args.memoryBodyId, exec.signal);
-			const results = await service.related(args.id, args.depth, args.edge, exec.signal, args.memoryBodyId);
+			const results = await runtimeFor(exec).service.related(args.id, args.depth, args.edge, exec.signal, args.memoryBodyId);
 			return {
 				id: args.id,
 				depth: args.depth ?? 2,
@@ -5114,7 +5704,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			schema: JSON_OBJECT_OUTPUT,
 			render: (_args, value) => text(value)
 		},
-		execute: (_args, exec) => service.status(exec.signal),
+		execute: (_args, exec) => runtimeFor(exec).service.status(exec.signal),
 		presentCall: () => ({
 			card: "generic",
 			title: "Check Mnemon status",
@@ -5151,7 +5741,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			render: (_args, value) => text(value)
 		},
 		async execute(args, exec) {
-			const controller = documents.forAgent(requireAgent(exec));
+			const controller = runtimeFor(exec).documents.forAgent(requireAgent(exec));
 			const result = await controller.search(args.query, {
 				...args.includeArchived === void 0 ? {} : { includeArchived: args.includeArchived },
 				limit: Math.min(8, args.limit ?? 8)
@@ -5229,7 +5819,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			render: (_args, value) => text(value)
 		},
 		execute: (args, exec) => {
-			if (!service.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
+			if (!config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
 			const agent = requireAgent(exec);
 			if (args.action === "archive") {
 				if (isSubagent(agent)) throw new Error("idle document workers cannot cold-archive directly");
@@ -5252,7 +5842,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 				...args.sourcePaths === void 0 ? {} : { sourcePaths: args.sourcePaths },
 				sessionIds: [agent.id]
 			};
-			return isSubagent(agent) ? documents.forAgent(agent).mutate(request) : coordinator.document(agent, request, exec.signal);
+			return isSubagent(agent) ? runtimeFor(exec).documents.forAgent(agent).mutate(request) : coordinator.document(agent, request, exec.signal);
 		},
 		presentCall: (args) => ({
 			card: "generic",
@@ -5310,7 +5900,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			render: (_args, value) => text(value)
 		},
 		execute: (args, exec) => {
-			if (!service.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
+			if (!config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
 			const request = {
 				action: args.action,
 				target: args.target,
@@ -5318,7 +5908,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 				...args.old_text === void 0 ? {} : { oldText: args.old_text },
 				...args.importance === void 0 ? {} : { importance: args.importance }
 			};
-			return isSubagent(exec.agent) ? runtimeMemory.mutate(request) : coordinator.runtime(requireAgent(exec), request, exec.signal);
+			return isSubagent(exec.agent) ? runtimeFor(exec).runtimeMemory.mutate(request) : coordinator.runtime(requireAgent(exec), request, exec.signal);
 		},
 		presentCall: (args) => ({
 			card: "generic",
@@ -5379,7 +5969,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 				...args,
 				source: args.source ?? "agent"
 			};
-			return isSubagent(exec.agent) ? service.remember(request, exec.signal) : coordinator.remember(requireAgent(exec), request, exec.signal);
+			return isSubagent(exec.agent) ? runtimeFor(exec).service.remember(request, exec.signal) : coordinator.remember(requireAgent(exec), request, exec.signal);
 		},
 		presentCall: () => ({
 			card: "generic",
@@ -5420,7 +6010,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			render: (_args, value) => text(value)
 		},
 		async execute(args, exec) {
-			return isSubagent(exec.agent) ? service.link(args.sourceId, args.targetId, args.type, args.weight, args.reason, exec.signal, args.memoryBodyId) : coordinator.write(requireAgent(exec), "link", args, exec.signal);
+			return isSubagent(exec.agent) ? runtimeFor(exec).service.link(args.sourceId, args.targetId, args.type, args.weight, args.reason, exec.signal, args.memoryBodyId) : coordinator.write(requireAgent(exec), "link", args, exec.signal);
 		},
 		presentCall: () => ({
 			card: "generic",
@@ -5450,7 +6040,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			schema: JSON_OBJECT_OUTPUT,
 			render: (_args, value) => text(value)
 		},
-		execute: (args, exec) => isSubagent(exec.agent) ? service.forget(args.id, exec.signal, args.memoryBodyId) : coordinator.write(requireAgent(exec), "forget", args, exec.signal),
+		execute: (args, exec) => isSubagent(exec.agent) ? runtimeFor(exec).service.forget(args.id, exec.signal, args.memoryBodyId) : coordinator.write(requireAgent(exec), "forget", args, exec.signal),
 		presentCall: (args) => ({
 			card: "generic",
 			title: "Forget Mnemon insight",
@@ -5483,7 +6073,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			schema: JSON_OBJECT_OUTPUT,
 			render: (_args, value) => text(value)
 		},
-		execute: (args, exec) => isSubagent(exec.agent) ? service.createBody(args, exec.signal) : coordinator.write(requireAgent(exec), "create-memory-body", args, exec.signal),
+		execute: (args, exec) => isSubagent(exec.agent) ? runtimeFor(exec).service.createBody(args, exec.signal) : coordinator.write(requireAgent(exec), "create-memory-body", args, exec.signal),
 		presentCall: () => ({
 			card: "generic",
 			title: "Create Mnemon Memory Space",
@@ -5511,7 +6101,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			schema: JSON_OBJECT_OUTPUT,
 			render: (_args, value) => text(value)
 		},
-		execute: (args, exec) => isSubagent(exec.agent) ? service.updateBody(args.memoryBodyId, args) : coordinator.write(requireAgent(exec), "update-memory-body", args, exec.signal),
+		execute: (args, exec) => isSubagent(exec.agent) ? runtimeFor(exec).service.updateBody(args.memoryBodyId, args) : coordinator.write(requireAgent(exec), "update-memory-body", args, exec.signal),
 		presentCall: () => ({
 			card: "generic",
 			title: "Update Mnemon Memory Space",
@@ -5545,7 +6135,7 @@ function registerTools(ctx, service, coordinator, runtimeMemory, documents) {
 			schema: JSON_OBJECT_OUTPUT,
 			render: (_args, value) => text(value)
 		},
-		execute: (args, exec) => isSubagent(exec.agent) ? service.mergeBodies(args.targetMemoryBodyId, args.sourceMemoryBodyIds, args.deactivateSources ?? true, exec.signal) : coordinator.write(requireAgent(exec), "merge-memory-bodies", args, exec.signal),
+		execute: (args, exec) => isSubagent(exec.agent) ? runtimeFor(exec).service.mergeBodies(args.targetMemoryBodyId, args.sourceMemoryBodyIds, args.deactivateSources ?? true, exec.signal) : coordinator.write(requireAgent(exec), "merge-memory-bodies", args, exec.signal),
 		presentCall: () => ({
 			card: "generic",
 			title: "Merge Mnemon Memory Spaces",
@@ -5565,7 +6155,8 @@ const inject = [
 	"settings",
 	"commands",
 	"agents",
-	"subagents"
+	"subagents",
+	"workspaceRegistry"
 ];
 /** Mount native model tools on every DSH surface and UI RPC only when Web connection exists. */
 function apply(rawContext, config = {}) {
@@ -5578,7 +6169,7 @@ function apply(rawContext, config = {}) {
 			prepared.set(value, createRuntimeGraph(resolveConfig(value)));
 		}
 	}).get();
-	const runtime = new LiveMnemonRuntime(prepared.get(initialSettings) ?? createRuntimeGraph(resolveConfig(initialSettings)));
+	const runtime = new LiveMnemonRuntime(prepared.get(initialSettings) ?? createRuntimeGraph(resolveConfig(initialSettings)), ctx.workspaceRegistry, ctx.agents);
 	const resolved = runtime.config;
 	ctx.on("settings/updated", ((namespace, next) => {
 		if (namespace !== "mnemon") return;
@@ -5588,17 +6179,17 @@ function apply(rawContext, config = {}) {
 		base: resolveInteractionConfig(resolved.conversationInteraction),
 		applies: "live"
 	});
-	const coordinator = new MnemonSubagentCoordinator(ctx.subagents, runtime.runtimeMemory, runtime.documents);
-	const lifecycle = new MnemonLifecycle(ctx, coordinator, resolved);
+	const coordinator = new MnemonSubagentCoordinator(ctx.subagents, runtime);
+	const lifecycle = new MnemonLifecycle(ctx, coordinator, runtime.config, runtime);
 	ctx.effect(() => lifecycle.start(), "dsh-mnemon.lifecycle-root()");
-	registerTools(ctx, runtime.service, coordinator, runtime.runtimeMemory, runtime.documents);
-	registerCommands(ctx.commands, runtime.service, coordinator);
+	registerTools(ctx, runtime, coordinator);
+	registerCommands(ctx.commands, runtime, coordinator);
 	registerGuidance(ctx, resolved);
 	registerRuntimeMemoryContext(ctx, runtime.runtimeMemory);
 	ctx.inject(["connection"], (webContext) => {
-		registerRpc(webContext.connection, runtime.service, lifecycle, runtime.runtimeMemory, runtime.storage, runtime.packs);
+		registerRpc(webContext.connection, runtime, lifecycle);
 		registerSettingsRpc(webContext.connection, ctx.settings);
 	});
 }
 //#endregion
-export { Config, DocumentManager, InteractionConfig, LiveMnemonRuntime, MnemonLifecycle, MnemonPackManager, MnemonService, MnemonSubagentCoordinator, RuntimeMemoryController, StorageScopeInspector, apply, createRunner, createRuntimeGraph, inject, name, resolveConfig, resolveInteractionConfig };
+export { Config, DocumentManager, InteractionConfig, LiveMnemonRuntime, MnemonLifecycle, MnemonPackManager, MnemonService, MnemonSubagentCoordinator, RuntimeMemoryController, StorageScopeInspector, VersionUpdateManager, apply, createRunner, createRuntimeGraph, inject, name, resolveConfig, resolveInteractionConfig };