dsh-mnemon 0.5.2 → 0.5.4

package/lib/index.js

@@ -1,9 +1,10 @@
-import { t as withMemoryStorageLock } from "./storage-lock-Bqrhkyag.js";
+import { i as withMemoryStorageLock, n as memoryStrategyConfigurationValues, r as readMemoryStrategyConfiguration } from "./strategy-configuration-B_DsZRQG.js";
 import { a as prepareMemoryContributions, i as validateMemoryPluginGraph, n as MemoryCompositionGeneration, r as captureMemoryContributionSnapshot, t as provideMemoryRuntime } from "./runtime-AtIOTeP1.js";
 import { DEFAULT_MEMORY_VIEW_BUDGET, MEMORY_CAPABILITIES } from "./contracts.js";
 import { r as defineMemoryPlugin, t as canonicalMemoryJson } from "./definitions-j0FLgE0-.js";
 import z from "schemastery";
 import { basename, delimiter, dirname, isAbsolute, join, normalize, resolve } from "node:path";
+import { resolveEmbedding, resolvePersistenceStrategy, resolveRecallQuality } from "dsh-mnemon-source-memory-spaces";
 import { createHash, randomUUID } from "node:crypto";
 import { accessSync, closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -11,6 +12,7 @@ import { strToU8, unzipSync, zipSync } from "fflate";
 import { DOCUMENTS_ACTIVE_LIMIT_BYTES, DOCUMENTS_VERSION } from "dsh-mnemon-source-documents/contracts";
 import { RUNTIME_ENTRY_DELIMITER, RUNTIME_MEMORY_LIMITS, RUNTIME_MEMORY_VERSION } from "dsh-mnemon-source-runtime/contracts";
 import { fileURLToPath } from "node:url";
+import { findMnemonCommand, mnemonNpmLauncher } from "dsh-mnemon-source-memory-spaces/native-cli";
 import { spawn } from "node:child_process";
 import { z as z$1 } from "zod";
 //#region src/host/display-mode.ts
@@ -73,9 +75,13 @@ const MAX_RUNTIME_MEMORY_LIMIT_BYTES = 1048576;
 const DEFAULT_RUNTIME_MAINTENANCE_MAX_TOKENS = 8192;
 const MAX_RUNTIME_MAINTENANCE_MAX_TOKENS = 1e6;
 const DEFAULT_TIMEOUT_MS = 1e4;
-const DEFAULT_RECALL_QUALITY_POLICY = "strict-v1";
-const DEFAULT_RECALL_LOW_SCORE_THRESHOLD = .25;
-const DEFAULT_RECALL_HIGH_SCORE_THRESHOLD = .6;
+const recallDefaults = resolveRecallQuality(void 0);
+const DEFAULT_RECALL_QUALITY_POLICY = recallDefaults.policy;
+const DEFAULT_RECALL_LOW_SCORE_THRESHOLD = recallDefaults.lowScoreThreshold;
+const DEFAULT_RECALL_HIGH_SCORE_THRESHOLD = recallDefaults.highScoreThreshold;
+const DEFAULT_RECALL_CANDIDATE_MULTIPLIER = recallDefaults.candidateMultiplier;
+const DEFAULT_RECALL_MAX_MEDIUM_RESULTS = recallDefaults.maxMediumResults;
+const DEFAULT_RECALL_MAX_UNKNOWN_RESULTS = recallDefaults.maxUnknownResults;
 //#endregion
 //#region src/host/config.ts
 const InteractionConfig = z.object({
@@ -127,9 +133,9 @@ const RecallQualitySchema = z.object({
 	policy: z.string().default(DEFAULT_RECALL_QUALITY_POLICY),
 	lowScoreThreshold: z.number().min(0).max(1).default(DEFAULT_RECALL_LOW_SCORE_THRESHOLD),
 	highScoreThreshold: z.number().min(0).max(1).default(DEFAULT_RECALL_HIGH_SCORE_THRESHOLD),
-	candidateMultiplier: z.number().step(1).min(1).max(5).default(3),
-	maxMediumResults: z.number().step(1).min(0).max(50).default(4),
-	maxUnknownResults: z.number().step(1).min(0).max(50).default(2)
+	candidateMultiplier: z.number().step(1).min(1).max(5).default(DEFAULT_RECALL_CANDIDATE_MULTIPLIER),
+	maxMediumResults: z.number().step(1).min(0).max(50).default(DEFAULT_RECALL_MAX_MEDIUM_RESULTS),
+	maxUnknownResults: z.number().step(1).min(0).max(50).default(DEFAULT_RECALL_MAX_UNKNOWN_RESULTS)
 });
 const RuntimeMemorySchema = z.object({
 	memoryLimitBytes: z.number().step(1).min(1).max(MAX_RUNTIME_MEMORY_LIMIT_BYTES).default(DEFAULT_RUNTIME_MEMORY_LIMIT_BYTES),
@@ -191,9 +197,9 @@ const Config = z.object({
 		policy: DEFAULT_RECALL_QUALITY_POLICY,
 		lowScoreThreshold: DEFAULT_RECALL_LOW_SCORE_THRESHOLD,
 		highScoreThreshold: DEFAULT_RECALL_HIGH_SCORE_THRESHOLD,
-		candidateMultiplier: 3,
-		maxMediumResults: 4,
-		maxUnknownResults: 2
+		candidateMultiplier: DEFAULT_RECALL_CANDIDATE_MULTIPLIER,
+		maxMediumResults: DEFAULT_RECALL_MAX_MEDIUM_RESULTS,
+		maxUnknownResults: DEFAULT_RECALL_MAX_UNKNOWN_RESULTS
 	}),
 	routingGuidance: z.boolean().default(true),
 	displayMode: z.union([
@@ -335,106 +341,6 @@ function resolveMemoryTopology(value) {
 		layers
 	};
 }
-const MEMORY_PROVIDER_ID = /^[a-z][a-z0-9-]{0,127}$/u;
-const MEMORY_PLACEMENT_CAPABILITY_SET = /* @__PURE__ */ new Set([
-	"graph",
-	"entities",
-	"related",
-	"exact-write",
-	"link",
-	"forget"
-]);
-const MEMORY_PLACEMENT_PREFERENCE_SET = /* @__PURE__ */ new Set([
-	"balanced",
-	"local-first",
-	"shared-first"
-]);
-function resolvePersistenceStrategy(value) {
-	const mode = value?.mode ?? "manual";
-	if (mode !== "manual" && mode !== "automatic") throw new Error(`dsh-mnemon: unsupported persistence strategy mode: ${String(mode)}`);
-	const providerId = value?.providerId ?? "mnemon-native";
-	if (!MEMORY_PROVIDER_ID.test(providerId)) throw new Error(`dsh-mnemon: invalid persistence strategy provider: ${String(providerId)}`);
-	const prompt = value?.prompt?.trim() ?? "";
-	if (prompt.length > 4e3) throw new Error("dsh-mnemon: persistence strategy prompt is too long (max 4000 characters)");
-	const configuredProviderIds = value?.rules?.allowedProviderIds;
-	const allowedProviderIds = [...new Set(configuredProviderIds === void 0 || configuredProviderIds.length === 0 && mode === "manual" ? ["mnemon-native"] : configuredProviderIds)];
-	if (allowedProviderIds.length === 0) throw new Error("dsh-mnemon: persistence strategy requires at least one allowed provider");
-	for (const id of allowedProviderIds) if (!MEMORY_PROVIDER_ID.test(id)) throw new Error(`dsh-mnemon: invalid persistence strategy provider: ${String(id)}`);
-	const dataBoundary = value?.rules?.dataBoundary ?? "allow-remote";
-	if (dataBoundary !== "allow-remote" && dataBoundary !== "local-only") throw new Error(`dsh-mnemon: unsupported persistence data boundary: ${String(dataBoundary)}`);
-	const requiredCapabilities = [...new Set(value?.rules?.requiredCapabilities ?? [])];
-	for (const capability of requiredCapabilities) if (!MEMORY_PLACEMENT_CAPABILITY_SET.has(capability)) throw new Error(`dsh-mnemon: unsupported persistence capability: ${String(capability)}`);
-	const preference = value?.rules?.preference ?? "balanced";
-	if (!MEMORY_PLACEMENT_PREFERENCE_SET.has(preference)) throw new Error(`dsh-mnemon: unsupported persistence preference: ${String(preference)}`);
-	const providerConnections = Object.fromEntries(Object.entries(value?.providerConnections ?? {}).flatMap(([id, connection]) => {
-		if (!MEMORY_PROVIDER_ID.test(id) || connection === void 0) return [];
-		return [[id, Object.fromEntries(Object.entries(connection).filter((entry) => [
-			"string",
-			"number",
-			"boolean"
-		].includes(typeof entry[1])))]];
-	}));
-	return {
-		mode,
-		providerId,
-		prompt,
-		rules: {
-			allowedProviderIds,
-			dataBoundary,
-			requiredCapabilities,
-			preference
-		},
-		providerConnections
-	};
-}
-function resolveEmbedding(value) {
-	const endpoint = optionalText(value?.endpoint) ?? "http://localhost:11434";
-	if (endpoint.length > 2048) throw new Error("dsh-mnemon: embedding endpoint is too long");
-	let parsed;
-	try {
-		parsed = new URL(endpoint);
-	} catch {
-		throw new Error("dsh-mnemon: embedding endpoint must be an absolute HTTP or HTTPS URL");
-	}
-	if (!["http:", "https:"].includes(parsed.protocol) || parsed.username !== "" || parsed.password !== "" || endpoint.includes("?") || endpoint.includes("#")) throw new Error("dsh-mnemon: embedding endpoint must be an absolute HTTP or HTTPS URL without credentials, query, or fragment");
-	const normalizedEndpoint = endpoint.replace(/\/+$/u, "");
-	const model = optionalText(value?.model) ?? "nomic-embed-text";
-	if (model.length > 200 || /[\u0000-\u001f\u007f]/u.test(model)) throw new Error("dsh-mnemon: embedding model must contain 1..200 characters without control characters");
-	const apiKey = optionalText(value?.apiKey) ?? "";
-	if (apiKey.length > 2048 || /[\u0000-\u001f\u007f]/u.test(apiKey)) throw new Error("dsh-mnemon: embedding API key must contain 0..2048 characters without control characters");
-	const protocol = value?.protocol ?? "auto";
-	if (!MNEMON_EMBEDDING_PROTOCOLS.includes(protocol)) throw new Error(`dsh-mnemon: unsupported embedding protocol: ${String(protocol)}`);
-	return {
-		enabled: value?.enabled === true,
-		endpoint: normalizedEndpoint,
-		model,
-		apiKey,
-		protocol
-	};
-}
-function resolveRecallQuality(value) {
-	const policy = optionalText(value?.policy) ?? "strict-v1";
-	if (!/^[a-z][a-z0-9-]{0,63}$/u.test(policy)) throw new Error("dsh-mnemon: recall quality policy id must match [a-z][a-z0-9-]{0,63}");
-	const lowScoreThreshold = value?.lowScoreThreshold ?? .25;
-	const highScoreThreshold = value?.highScoreThreshold ?? .6;
-	const candidateMultiplier = value?.candidateMultiplier ?? 3;
-	const maxMediumResults = value?.maxMediumResults ?? 4;
-	const maxUnknownResults = value?.maxUnknownResults ?? 2;
-	if (!Number.isFinite(lowScoreThreshold) || lowScoreThreshold < 0 || lowScoreThreshold > 1) throw new Error("dsh-mnemon: recall low score threshold must be within 0..1");
-	if (!Number.isFinite(highScoreThreshold) || highScoreThreshold < 0 || highScoreThreshold > 1) throw new Error("dsh-mnemon: recall high score threshold must be within 0..1");
-	if (lowScoreThreshold >= highScoreThreshold) throw new Error("dsh-mnemon: recall low score threshold must be less than the high score threshold");
-	if (!Number.isInteger(candidateMultiplier) || candidateMultiplier < 1 || candidateMultiplier > 5) throw new Error("dsh-mnemon: recall candidate multiplier must be an integer within 1..5");
-	if (!Number.isInteger(maxMediumResults) || maxMediumResults < 0 || maxMediumResults > 50) throw new Error("dsh-mnemon: recall max medium results must be an integer within 0..50");
-	if (!Number.isInteger(maxUnknownResults) || maxUnknownResults < 0 || maxUnknownResults > 50) throw new Error("dsh-mnemon: recall max unknown results must be an integer within 0..50");
-	return {
-		policy,
-		lowScoreThreshold,
-		highScoreThreshold,
-		candidateMultiplier,
-		maxMediumResults,
-		maxUnknownResults
-	};
-}
 function resolveConfig(config = {}) {
 	const cliPath = optionalText(config.cliPath);
 	const legacyDataDir = optionalText(config.dataDir);
@@ -1347,7 +1253,7 @@ function runtimeArea(root) {
 		};
 	}
 }
-function memoryBodiesArea(root) {
+function memorySpacesArea(root) {
 	const path = join(root, "data");
 	if (!existsSync(path)) return missing("memory-bodies", path);
 	try {
@@ -1369,7 +1275,7 @@ function memoryBodiesArea(root) {
 				databases: databaseCount,
 				registry: existsSync(registryPath)
 			},
-			...invalidRegistry ? { issue: "memory-body registry is invalid" } : {}
+			...invalidRegistry ? { issue: "memory-space registry is invalid" } : {}
 		};
 	} catch (error) {
 		return {
@@ -1468,7 +1374,7 @@ function inspect(kind, rawRoot, activeRoot) {
 	const root = canonical(rawRoot);
 	const areas = [
 		runtimeArea(root),
-		memoryBodiesArea(root),
+		memorySpacesArea(root),
 		documentsArea(root),
 		stateArea(root)
 	];
@@ -1902,6 +1808,200 @@ function assertParticipation(config, sourceTypeId, capability, trigger) {
 	if (!allowsParticipation(config, sourceTypeId, capability, trigger)) throw new Error(`Memory Source ${sourceTypeId} does not allow ${trigger} ${participationChannel(capability)} in the current configuration`);
 }
 //#endregion
+//#region src/host/memory-executions.ts
+/** One Host owner pairs each Core turn with its runtime binding. */
+var MemoryExecutions = class {
+	runtime;
+	slots = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Set();
+	closed = false;
+	constructor(runtime) {
+		this.runtime = runtime;
+	}
+	async turn(agent, turn, signal, delegation) {
+		signal.throwIfAborted();
+		const slot = this.open(agent, "turn", `${agent.id}:${turn}`, "agent.root-turn", delegation);
+		const abort = () => slot.controller.abort(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		try {
+			const execution = await slot.ready;
+			signal.throwIfAborted();
+			return {
+				...execution,
+				release: () => {
+					signal.removeEventListener("abort", abort);
+					slot.close();
+				}
+			};
+		} catch (error) {
+			signal.removeEventListener("abort", abort);
+			slot.close();
+			throw error;
+		}
+	}
+	async workflow(agent, operation, signal) {
+		this.assertOpen();
+		signal.throwIfAborted();
+		let slot = this.slots.get(agent.id);
+		if (slot?.closing) slot = void 0;
+		if (slot === void 0) {
+			const graph = this.runtime.forAgent(agent);
+			const context = graph.composableTurns.activeTurn(agent.id);
+			if (!this.slots.has(agent.id) && context !== void 0) return {
+				graph,
+				context,
+				signal,
+				release() {}
+			};
+			slot = this.open(agent, "workflow", "workflow:" + randomUUID(), "agent." + operation);
+		}
+		const current = slot;
+		if (current.kind === "turn") return {
+			...await untilAborted(current.ready, signal),
+			signal,
+			release() {}
+		};
+		current.users += 1;
+		let released = false;
+		const release = () => {
+			if (released) return;
+			released = true;
+			if (--current.users === 0) current.close();
+		};
+		try {
+			return {
+				...await untilAborted(current.ready, signal),
+				signal: AbortSignal.any([signal, current.controller.signal]),
+				release
+			};
+		} catch (error) {
+			release();
+			throw error;
+		}
+	}
+	retain(agent, delegation) {
+		this.assertOpen();
+		const releaseView = delegation.viewId === void 0 ? void 0 : delegation.graph.composableTurns.retainView(delegation.viewId);
+		try {
+			const releaseRuntime = this.runtime.bindAgentRuntime(agent.id, delegation.graph);
+			return () => {
+				try {
+					releaseView?.();
+				} finally {
+					releaseRuntime();
+				}
+			};
+		} catch (error) {
+			releaseView?.();
+			throw error;
+		}
+	}
+	dispose() {
+		this.closed = true;
+		for (const slot of this.pending) {
+			slot.controller.abort(/* @__PURE__ */ new Error("Mnemon runtime is disposed"));
+			if (slot.kind === "turn") slot.close();
+		}
+	}
+	open(agent, kind, turnId, purpose, delegation) {
+		this.assertOpen();
+		const previous = this.slots.get(agent.id);
+		const done = deferred();
+		const ready = deferred();
+		let execution;
+		const finish = () => {
+			if (this.slots.get(agent.id) === slot) this.slots.delete(agent.id);
+			this.pending.delete(slot);
+			done.resolve();
+		};
+		const slot = {
+			kind,
+			users: 0,
+			closing: false,
+			controller: new AbortController(),
+			done: done.promise,
+			ready: ready.promise,
+			close: () => {
+				if (slot.closing) return;
+				slot.closing = true;
+				slot.controller.abort(/* @__PURE__ */ new Error("memory execution ended"));
+				if (execution !== void 0) try {
+					execution.release();
+				} finally {
+					finish();
+				}
+			}
+		};
+		this.slots.set(agent.id, slot);
+		this.pending.add(slot);
+		(async () => {
+			await previous?.done;
+			slot.controller.signal.throwIfAborted();
+			this.assertOpen();
+			const graph = delegation?.graph ?? this.runtime.forAgent(agent);
+			const manager = graph.composableTurns;
+			const scope = delegation === void 0 ? agentScope(agent, graph.config) : {
+				...delegation.scope,
+				sessionId: agent.id,
+				agentId: agent.id
+			};
+			const releaseRuntime = delegation === void 0 ? this.runtime.bindAgentRuntime(agent.id, graph) : void 0;
+			let context;
+			const release = () => {
+				try {
+					if (context !== void 0 && manager.turn(context.turnId) === context) manager.endTurn(context.turnId);
+				} finally {
+					releaseRuntime?.();
+				}
+			};
+			try {
+				context = delegation?.viewId === void 0 ? await manager.beginTurn(turnId, scope, purpose, slot.controller.signal) : manager.pinTurn(turnId, scope, delegation.viewId);
+				slot.controller.signal.throwIfAborted();
+				execution = {
+					graph,
+					context,
+					release
+				};
+				return execution;
+			} catch (error) {
+				release();
+				throw error;
+			}
+		})().then(ready.resolve, (error) => {
+			finish();
+			ready.reject(error);
+		});
+		slot.ready.catch(() => {});
+		return slot;
+	}
+	assertOpen() {
+		if (this.closed) throw new Error("Mnemon runtime is disposed");
+	}
+};
+async function untilAborted(promise, signal) {
+	signal.throwIfAborted();
+	const aborted = deferred();
+	const abort = () => aborted.reject(signal.reason);
+	signal.addEventListener("abort", abort, { once: true });
+	try {
+		return await Promise.race([promise, aborted.promise]);
+	} finally {
+		signal.removeEventListener("abort", abort);
+	}
+}
+function deferred() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((yes, no) => {
+			resolve = yes;
+			reject = no;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
 //#region src/host/runtime.ts
 function agentScope(agent, config) {
 	const workspaceId = agent.session.header?.cwd?.trim();
@@ -2017,6 +2117,7 @@ var LiveMnemonRuntime = class {
 	workspaceRegistry;
 	agents;
 	extensions;
+	executions = new MemoryExecutions(this);
 	current;
 	workspaceGraphs = /* @__PURE__ */ new Map();
 	agentGraphs = /* @__PURE__ */ new Map();
@@ -2067,6 +2168,7 @@ var LiveMnemonRuntime = class {
 	}
 	dispose() {
 		if (this.closed) return;
+		this.executions.dispose();
 		this.closed = true;
 		const graphs = /* @__PURE__ */ new Set([
 			this.current,
@@ -2171,7 +2273,7 @@ function clip(value, max = 600) {
 }
 function insightLine(insight, index) {
 	const meta = [
-		insight.memoryBodyId === void 0 ? void 0 : `body=${insight.memoryBodyId}`,
+		insight.memoryBodyId === void 0 ? void 0 : `space=${insight.memoryBodyId}`,
 		insight.category,
 		insight.score === void 0 ? void 0 : `score=${insight.score.toFixed(3)}`,
 		insight.depth === void 0 ? void 0 : `depth=${insight.depth}`
@@ -2257,7 +2359,7 @@ async function execute(serviceOrSource, coordinator, invocation) {
 			}, invocation.signal);
 			return {
 				kind: "success",
-				text: `Mnemon 记忆 Agent 已处理：${result.action}${result.memoryBodyIds.length === 0 ? "" : ` · 记忆体 ${result.memoryBodyIds.join(", ")}`}${result.summary === "" ? "" : `\n${result.summary}`}`
+				text: `Mnemon 记忆 Agent 已处理：${result.action}${result.memoryBodyIds.length === 0 ? "" : ` · 记忆空间 ${result.memoryBodyIds.join(", ")}`}${result.summary === "" ? "" : `\n${result.summary}`}`
 			};
 		}
 		case "forget":
@@ -3174,7 +3276,6 @@ var MnemonSubagentCoordinator = class {
 	runtimeQueue = Promise.resolve();
 	documentQueue = Promise.resolve();
 	observedReads = /* @__PURE__ */ new WeakMap();
-	workflows = /* @__PURE__ */ new Map();
 	constructor(subagents, runtimeSource, resultRuntime, taskAgentModelResolver, runtimeMaintenanceMaxTokensResolver) {
 		this.subagents = subagents;
 		this.runtimeSource = runtimeSource;
@@ -3216,10 +3317,10 @@ var MnemonSubagentCoordinator = class {
 		signal.throwIfAborted();
 		const graph = this.runtimeSource.forAgent(parent);
 		if (required && graph.composableTurns.activeTurn(parent.id) === void 0) throw new Error("Recall requires the View pinned to the current turn");
-		const release = await this.acquireWorkflow(parent, graph, routeId);
+		const execution = await this.runtimeSource.executions.workflow(parent, routeId, signal);
 		try {
-			const turn = this.turnAuthority(parent, true).context;
-			const evidence = await graph.source(typeId, turn.scope).forTurn(turn).route(routeId, input, signal);
+			const turn = execution.context;
+			const evidence = await execution.graph.source(typeId, turn.scope).forTurn(turn).route(routeId, input, execution.signal);
 			if (typeId === "memory-spaces" && ["recall", "related"].includes(routeId)) {
 				const observed = this.observedReads.get(turn) ?? /* @__PURE__ */ new Set();
 				if (!observed.has(evidence.id)) {
@@ -3233,7 +3334,7 @@ var MnemonSubagentCoordinator = class {
 			this.counters.failures += 1;
 			throw error;
 		} finally {
-			release();
+			execution.release();
 		}
 	}
 	/** Bind a model read to the Source state pinned by its own executing turn. */
@@ -3697,10 +3798,13 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 		let failure;
 		let disposeResultTool;
 		let disposeResultObserver;
-		const graph = this.runtimeSource.forAgent(parent);
 		let releaseWorkflow;
 		try {
-			if (tools.length > 0) releaseWorkflow = await this.acquireWorkflow(parent, graph, operation);
+			if (tools.length > 0) {
+				const execution = await this.runtimeSource.executions.workflow(parent, operation, signal);
+				releaseWorkflow = execution.release;
+				signal = execution.signal;
+			}
 			const observer = this.resultRuntime.on("tools/result", ((execution, result) => {
 				if (execution.token !== void 0) {
 					const entries = stagedReceipts.get(execution.token);
@@ -3846,43 +3950,6 @@ Completion protocol: call \`${resultToolName}\` exactly once with the final resu
 			if (cleanupFailure !== void 0) throw cleanupFailure;
 		}
 	}
-	/** Concurrent maintenance children share one owned View until the last exits. */
-	async acquireWorkflow(parent, graph, operation) {
-		const scope = agentScope(parent, graph.config);
-		const key = scope.agentId;
-		let owned = this.workflows.get(key);
-		if (owned === void 0) {
-			if (graph.composableTurns.activeTurn(key) !== void 0) return () => {};
-			const turnId = "workflow:" + randomUUID();
-			const releaseRuntime = this.runtimeSource.bindAgentRuntime(parent.id, graph);
-			owned = {
-				users: 0,
-				ready: graph.composableTurns.beginTurn(turnId, scope, "agent." + operation),
-				release: () => {
-					graph.composableTurns.endTurn(turnId);
-					releaseRuntime();
-				}
-			};
-			this.workflows.set(key, owned);
-		}
-		owned.users += 1;
-		const current = owned;
-		let released = false;
-		const release = () => {
-			if (released) return;
-			released = true;
-			if (--current.users > 0) return;
-			if (this.workflows.get(key) === current) this.workflows.delete(key);
-			current.release();
-		};
-		try {
-			await current.ready;
-		} catch (error) {
-			release();
-			throw error;
-		}
-		return release;
-	}
 	provider(preferred) {
 		const names = this.subagents.list();
 		const compatible = (name) => {
@@ -4322,15 +4389,6 @@ function inspectMemoryView(generation, view, state, turn, memoryText) {
 }
 //#endregion
 //#region src/host/agent-memory-turn.ts
-function agentMemoryScope(agent, graph) {
-	const cwd = agent.session.header?.cwd?.trim();
-	return {
-		storage: graph.config.storageScope,
-		...cwd === void 0 || cwd === "" ? {} : { workspaceId: resolve(cwd) },
-		sessionId: agent.id,
-		agentId: agent.id
-	};
-}
 /** The durable log, not a parent session id, identifies the executing turn. */
 function openAgentTurn(agent) {
 	let open;
@@ -4361,20 +4419,7 @@ var AgentMemoryTurn = class {
 		this.runtime = runtime;
 		this.delegation = delegation;
 		if (delegation === void 0) return;
-		const releaseView = delegation.viewId === void 0 ? void 0 : delegation.graph.composableTurns.retainView(delegation.viewId);
-		try {
-			const releaseRuntime = runtime.bindAgentRuntime(agent.id, delegation.graph);
-			this.releaseDelegation = () => {
-				try {
-					releaseView?.();
-				} finally {
-					releaseRuntime();
-				}
-			};
-		} catch (error) {
-			releaseView?.();
-			throw error;
-		}
+		this.releaseDelegation = runtime.executions.retain(agent, delegation);
 	}
 	get current() {
 		return this.pinned;
@@ -4403,7 +4448,7 @@ var AgentMemoryTurn = class {
 		const graph = this.runtime.forAgent(this.agent);
 		return {
 			graph,
-			scope: agentMemoryScope(this.agent, graph)
+			scope: agentScope(this.agent, graph.config)
 		};
 	}
 	async begin(turn, signal) {
@@ -4437,12 +4482,7 @@ var AgentMemoryTurn = class {
 		this.pending = void 0;
 		const pinned = this.pinned;
 		this.pinned = void 0;
-		if (pinned === void 0) return;
-		try {
-			if (pinned.manager.turn(pinned.context.turnId) === pinned.context) pinned.manager.endTurn(pinned.context.turnId);
-		} finally {
-			pinned.releaseRuntime?.();
-		}
+		pinned?.release();
 	}
 	dispose() {
 		if (this.closed) return;
@@ -4455,33 +4495,22 @@ var AgentMemoryTurn = class {
 		}
 	}
 	async pin(turn, generation, signal) {
-		const graph = this.delegation?.graph ?? this.runtime.forAgent(this.agent);
-		const manager = graph.composableTurns;
-		const scope = this.delegation === void 0 ? agentMemoryScope(this.agent, graph) : {
-			...this.delegation.scope,
-			sessionId: this.agent.id,
-			agentId: this.agent.id
-		};
-		const turnId = `${this.agent.id}:${turn}`;
-		const context = this.delegation?.viewId === void 0 ? await manager.beginTurn(turnId, scope, "agent.root-turn", signal) : manager.pinTurn(turnId, scope, this.delegation.viewId);
-		let releaseRuntime;
+		const execution = await this.runtime.executions.turn(this.agent, turn, signal, this.delegation);
+		const { graph, context } = execution;
 		try {
 			if (this.closed || this.generation !== generation) throw new Error("memory turn ended during View preparation");
 			signal?.throwIfAborted();
-			if (this.delegation === void 0) releaseRuntime = this.runtime.bindAgentRuntime(this.agent.id, graph);
 			const inspection = inspectMemoryView(graph.memoryComposition.generation(context.view.runtimeGeneration), context.view, "active", turn, modelMemoryWake(graph, context).text);
 			this.pinned = {
 				turn,
 				graph,
-				manager,
 				context,
-				...releaseRuntime === void 0 ? {} : { releaseRuntime }
+				release: execution.release
 			};
 			this.lastInspection = inspection;
 			this.lastWorkspace = context.scope.workspaceId === void 0 ? void 0 : resolve(context.scope.workspaceId);
 		} catch (error) {
-			if (manager.turn(context.turnId) === context) manager.endTurn(context.turnId);
-			releaseRuntime?.();
+			execution.release();
 			throw error;
 		}
 	}
@@ -4619,7 +4648,6 @@ var MnemonAgentLifecycle = class {
 	injectedMemoryText;
 	idleReviewTimer;
 	reviewController;
-	idleReviewRun;
 	reviewRunning = false;
 	lastReviewAt;
 	lastReviewAction;
@@ -4779,7 +4807,7 @@ var MnemonAgentLifecycle = class {
 		if (context.agent !== void 0 && context.agent.id !== this.agent.id) return next();
 		const turn = openAgentTurn(this.agent);
 		if (turn === void 0) return next();
-		await this.settleIdleReview();
+		this.cancelIdleReview(true);
 		if (context.signal?.aborted === true || openAgentTurn(this.agent) !== turn) return next();
 		await this.memoryTurn?.begin(turn, context.signal);
 		return applyMemoryViewGuidance(await next(), this.memoryTurn?.current?.context.view, this.config.routingGuidance);
@@ -4811,17 +4839,9 @@ var MnemonAgentLifecycle = class {
 			if (this.config.memoryTopology.strategyId !== "default-three-tier") return;
 			if (this.agent.status !== "idle") return;
 			if (!hostSessionEvents(this.agent.session).some((event) => event.type === "turn/end" && eventTurn(event) === turn) || !this.reviewActivity().eligible || !this.reviewAdmitted(turn)) return;
-			this.startIdleReview();
+			this.runIdleReview();
 		}, this.config.idleReviewMs);
 	}
-	startIdleReview() {
-		const run = this.runIdleReview();
-		this.idleReviewRun = run;
-		const clear = () => {
-			if (this.idleReviewRun === run) this.idleReviewRun = void 0;
-		};
-		run.then(clear, clear);
-	}
 	async runIdleReview() {
 		const controller = new AbortController();
 		const triggeredScore = this.reviewActivity().score;
@@ -4851,10 +4871,6 @@ var MnemonAgentLifecycle = class {
 		this.idleReviewTimer = void 0;
 		if (abortRunning) this.reviewController?.abort();
 	}
-	async settleIdleReview() {
-		this.cancelIdleReview(true);
-		await this.idleReviewRun;
-	}
 	ensureTurnActivity(turn) {
 		let activity = this.turnActivity.get(turn);
 		if (activity === void 0) {
@@ -5352,7 +5368,7 @@ var MnemonLifecycle = class {
 			const parentPin = graph.composableTurns.activeTurn(parent.id);
 			delegation = {
 				graph,
-				scope: parentPin?.scope ?? agentMemoryScope(parent, graph),
+				scope: parentPin?.scope ?? agentScope(parent, graph.config),
 				...parentPin === void 0 ? {} : { viewId: parentPin.view.id }
 			};
 		}
@@ -5477,7 +5493,11 @@ const runProcess = (command, args, options) => new Promise((resolve, reject) =>
 //#endregion
 //#region src/host/version-updates.ts
 const DSH_MNEMON_PACKAGE = "dsh-mnemon";
-const findMnemonCommand = (config) => config.cliPath ?? process.env.MNEMON_CLI_PATH ?? resolveExecutable("mnemon") ?? resolveExecutable("/opt/homebrew/bin/mnemon") ?? resolveExecutable(join(homedir(), ".local/bin/mnemon"));
+const MNEMON_NPM_PACKAGE = "@mnemon-dev/mnemon";
+const SUBPACKAGE = /^dsh-mnemon-(source|strategy|provider)-[a-z0-9][a-z0-9._-]*$/;
+function isVersionComponentId(value) {
+	return typeof value === "string" && (value === "mnemon" || value === DSH_MNEMON_PACKAGE || SUBPACKAGE.test(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));
 const CHECK_TIMEOUT_MS = 1e4;
@@ -5597,14 +5617,8 @@ async function fetchNpmLatest(name, tag = "latest") {
 	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 dependencySpec(profile, name = DSH_MNEMON_PACKAGE) {
+	return profile?.dependencies?.[name] ?? profile?.devDependencies?.[name];
 }
 function isLinkSpec(spec) {
 	return spec !== void 0 && /^(?:link|file|workspace):|^\.{1,2}(?:[/\\]|$)/.test(spec);
@@ -5620,6 +5634,7 @@ function profileFromAncestor(packageManifestPath) {
 		const profile = manifest$1(join(directory, "package.json"));
 		if (profile?.name?.startsWith("dsh-profile-") === true) {
 			const spec = dependencySpec(profile);
+			if (spec === void 0) return void 0;
 			const linked = isLinkSpec(spec);
 			return {
 				mode: linked ? "link" : "npm",
@@ -5683,6 +5698,23 @@ function updateOutput(result) {
 	const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n").trim();
 	return output === "" ? void 0 : output.slice(-4e3);
 }
+/** Follow public package links afresh after an update, without Node's resolution cache. */
+function packageAt(directory, name) {
+	for (let depth = 0; depth < 16; depth++) {
+		const path = join(directory, "node_modules", name, "package.json");
+		if (manifest$1(path)?.name === name) return path;
+		const parent = dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+}
+function samePath(left, right) {
+	try {
+		return realpathSync(left) === realpathSync(right);
+	} catch {
+		return false;
+	}
+}
 var VersionUpdateManager = class {
 	dshMnemonVersion;
 	packageManifestPath;
@@ -5692,6 +5724,8 @@ var VersionUpdateManager = class {
 	executable;
 	fetchNpmLatest;
 	fetchMnemonLatest;
+	pendingRestart = /* @__PURE__ */ new Set();
+	updating = false;
 	constructor(dependencies = {}) {
 		this.packageManifestPath = dependencies.packageManifestPath ?? PACKAGE_MANIFEST_PATH;
 		this.dshMnemonVersion = manifest$1(this.packageManifestPath)?.version ?? "0.0.0";
@@ -5700,39 +5734,87 @@ var VersionUpdateManager = class {
 		this.processRunner = dependencies.processRunner ?? runProcess;
 		this.executable = dependencies.resolveExecutable ?? resolveExecutable;
 		this.fetchNpmLatest = dependencies.fetchNpmLatest ?? fetchNpmLatest;
-		this.fetchMnemonLatest = dependencies.fetchMnemonLatest ?? fetchMnemonLatest;
+		this.fetchMnemonLatest = dependencies.fetchMnemonLatest ?? (() => this.fetchNpmLatest(MNEMON_NPM_PACKAGE));
 	}
 	get currentDshMnemonVersion() {
 		return this.dshMnemonVersion;
 	}
-	async latestDshMnemonVersion() {
-		const channel = parseSemver(this.currentDshMnemonVersion)?.prerelease[0];
+	async latestPackageVersion(name, current) {
+		const channel = current === void 0 ? void 0 : parseSemver(current)?.prerelease[0];
 		const tags = channel !== void 0 && [
 			"alpha",
 			"beta",
 			"rc"
 		].includes(channel) ? ["latest", channel] : ["latest"];
 		return (await Promise.all(tags.map(async (tag) => {
-			const version = await settledWithin(this.fetchNpmLatest(DSH_MNEMON_PACKAGE, tag), void 0);
+			const version = await settledWithin(this.fetchNpmLatest(name, tag), void 0);
 			const parsed = version === void 0 ? void 0 : parseSemver(version);
 			if (parsed === void 0) return void 0;
 			if (parsed.prerelease.length > 0 && (tag === "latest" || parsed.prerelease[0] !== tag)) return void 0;
 			return version;
 		}))).filter((version) => version !== void 0).sort(compareVersions).at(-1);
 	}
+	latestDshMnemonVersion() {
+		return this.latestPackageVersion(DSH_MNEMON_PACKAGE, this.currentDshMnemonVersion);
+	}
+	async latestMnemonVersion() {
+		const version = await settledWithin(this.fetchMnemonLatest(), void 0);
+		const parsed = version === void 0 ? void 0 : parseSemver(version);
+		return parsed !== void 0 && parsed.prerelease.length === 0 ? version : void 0;
+	}
+	npmInvocation() {
+		const npm = this.executable("npm");
+		if (npm === void 0) return void 0;
+		if (!/\.cmd$/i.test(npm)) return {
+			command: npm,
+			args: []
+		};
+		const cli = join(dirname(npm), "node_modules/npm/bin/npm-cli.js");
+		return existsSync(cli) ? {
+			command: process.execPath,
+			args: [cli]
+		} : void 0;
+	}
 	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" } };
+		const launcher = mnemonNpmLauncher(command);
 		let current;
 		try {
-			current = versionFrom((await resultOrThrow(this.processRunner, command, ["--version"], CHECK_TIMEOUT_MS)).stdout);
+			current = versionFrom((await resultOrThrow(this.processRunner, launcher === void 0 ? command : process.execPath, launcher === void 0 ? ["--version"] : [launcher, "--version"], CHECK_TIMEOUT_MS)).stdout);
 		} catch {
 			return { install: {
-				mode: "manual",
-				command
+				mode: launcher === void 0 ? "manual" : "npm",
+				command,
+				hint: "cli-unreadable"
 			} };
 		}
+		if (launcher !== void 0) {
+			const install = {
+				mode: "npm",
+				command,
+				hint: "npm-unmanaged"
+			};
+			const npm = this.npmInvocation();
+			if (npm === void 0) install.hint = "npm-missing";
+			else try {
+				const globalRoot = (await resultOrThrow(this.processRunner, npm.command, [
+					...npm.args,
+					"root",
+					"--global"
+				], CHECK_TIMEOUT_MS)).stdout.trim();
+				if (isAbsolute(globalRoot) && samePath(dirname(dirname(launcher)), join(globalRoot, MNEMON_NPM_PACKAGE))) {
+					install.hint = "npm";
+					install.updateCommand = process.execPath;
+					install.updateArgs = [launcher, "update"];
+				}
+			} catch {}
+			return {
+				install,
+				...current === void 0 ? {} : { current }
+			};
+		}
 		let realCommand = command;
 		try {
 			realCommand = realpathSync(command);
@@ -5813,13 +5895,60 @@ 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 profile = install.profileDir === void 0 ? void 0 : manifest$1(join(install.profileDir, "package.json"));
+		return [.../* @__PURE__ */ new Set([
+			...Object.keys(starter?.dependencies ?? {}),
+			...Object.keys(profile?.dependencies ?? {}),
+			...Object.keys(profile?.devDependencies ?? {})
+		])].filter((name) => SUBPACKAGE.test(name)).sort().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 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;
+			return {
+				...path === void 0 ? {} : { manifestPath: path },
+				status: {
+					id: name,
+					name,
+					kind: SUBPACKAGE.exec(name)[1],
+					managedBy,
+					...starter?.dependencies?.[name] === void 0 ? {} : { expectedVersion: starter.dependencies[name] },
+					...value?.version === void 0 ? {} : { current: value.version },
+					...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)
+				}
+			};
+		});
+	}
 	async check() {
-		const [mnemonLocal, mnemonLatest, dshLatest] = await Promise.all([
-			settledWithin(this.inspectMnemon(), { install: { mode: "missing" } }),
-			settledWithin(this.fetchMnemonLatest(), void 0),
-			settledWithin(this.latestDshMnemonVersion(), void 0)
-		]);
 		const dshInstall = inspectDshInstall(this.packageManifestPath, this.dshHome);
+		const [mnemonLocal, mnemonLatest, dshLatest, packages] = await Promise.all([
+			settledWithin(this.inspectMnemon(), { install: {
+				mode: "manual",
+				hint: "cli-unreadable"
+			} }),
+			this.latestMnemonVersion(),
+			settledWithin(this.latestDshMnemonVersion(), void 0),
+			Promise.all(this.subpackages(dshInstall).map(async ({ status }) => {
+				const latest = await this.latestPackageVersion(status.id, status.current);
+				return {
+					...status,
+					...latest === void 0 ? { checkError: "latest-unavailable" } : { latest },
+					outdated: status.current !== void 0 && latest !== void 0 && compareVersions(status.current, latest) < 0
+				};
+			}))
+		]);
 		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;
@@ -5836,7 +5965,7 @@ var VersionUpdateManager = class {
 				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",
+				updateHint: mnemonLocal.install.hint ?? (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",
@@ -5848,15 +5977,26 @@ var VersionUpdateManager = class {
 				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",
 				...dshLatest === void 0 ? { checkError: "latest-unavailable" } : {}
 			}]
 		};
 	}
 	async update(component) {
+		if (this.updating) throw new Error("A version update is already in progress");
+		this.updating = true;
+		try {
+			return await this.performUpdate(component);
+		} finally {
+			this.updating = false;
+		}
+	}
+	async performUpdate(component) {
 		if (component === "mnemon") {
 			const before = await this.inspectMnemon();
-			const latest = await this.fetchMnemonLatest();
+			const latest = await this.latestMnemonVersion();
 			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 {
@@ -5880,29 +6020,32 @@ var VersionUpdateManager = class {
 				...outputText === void 0 ? {} : { output: outputText }
 			};
 		}
-		if (component !== "dsh-mnemon") throw new Error(`Unknown version component: ${String(component)}`);
-		const latest = await this.latestDshMnemonVersion();
+		const install = inspectDshInstall(this.packageManifestPath, this.dshHome);
+		const child = component === DSH_MNEMON_PACKAGE ? void 0 : this.subpackages(install).find((item) => item.status.id === component)?.status;
+		if (component !== DSH_MNEMON_PACKAGE && child === void 0) throw new Error(`Unknown version component: ${String(component)}`);
+		if (child !== void 0 && !child.updateSupported) throw new Error("This subpackage must be updated through its Starter or original installation method");
+		const previousVersion = child?.current ?? this.currentDshMnemonVersion;
+		const latest = await this.latestPackageVersion(component, previousVersion);
 		if (latest === void 0) throw new Error("Unable to verify the latest dsh-mnemon release");
-		if (compareVersions(this.currentDshMnemonVersion, latest) >= 0) return {
+		if (compareVersions(previousVersion, latest) >= 0) return {
 			component,
-			previousVersion: this.currentDshMnemonVersion,
-			currentVersion: this.currentDshMnemonVersion,
+			previousVersion,
+			currentVersion: previousVersion,
 			updated: false,
-			restartRequired: false
+			restartRequired: this.pendingRestart.has(component)
 		};
-		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 previousVersion = this.currentDshMnemonVersion;
 		const output = await resultOrThrow(this.processRunner, pnpm, [
 			"add",
-			`${DSH_MNEMON_PACKAGE}@${latest}`,
+			`${component}@${latest}`,
 			"--save-exact"
 		], UPDATE_TIMEOUT_MS, { cwd: install.profileDir });
-		const installedVersion = manifest$1(join(install.profileDir, "node_modules", DSH_MNEMON_PACKAGE, "package.json"))?.version;
-		if (installedVersion !== latest) throw new Error(`dsh-mnemon update did not install the requested version ${latest}; found ${installedVersion ?? "no package"}`);
+		const installedVersion = manifest$1(join(install.profileDir, "node_modules", component, "package.json"))?.version;
+		if (installedVersion !== latest) throw new Error(`${component} update did not install the requested version ${latest}; found ${installedVersion ?? "no package"}`);
 		const outputText = updateOutput(output);
-		this.dshMnemonVersion = installedVersion;
+		if (component === DSH_MNEMON_PACKAGE) this.dshMnemonVersion = installedVersion;
+		this.pendingRestart.add(component);
 		return {
 			component,
 			previousVersion,
@@ -6274,7 +6417,8 @@ function createWriteHandler(input, lifecycle, versions) {
 			const payload = object$2(rawPayload);
 			if (endpoint === "version-update") {
 				if (versions === void 0) throw new Error("version updates are unavailable");
-				if (payload.component !== "mnemon" && payload.component !== "dsh-mnemon") return badRequest$1("unknown version component");
+				if (!input.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
+				if (!isVersionComponentId(payload.component)) return badRequest$1("unknown version component");
 				return success$1(await versions.update(payload.component));
 			}
 			const runtime = scoped(input, payload, lifecycle);
@@ -7464,39 +7608,6 @@ function legacyPreferences(value) {
 	for (const [entryId, item] of Object.entries(sources)) if (!ENTRY_ID.test(entryId) || typeof item?.enabled !== "boolean") throw new Error("Invalid legacy Source Entry preference");
 	return clone({ sources });
 }
-function configuration(definition, input) {
-	const config = record(input ?? {});
-	const fields = new Map(definition.fields.map((field) => [field.key, field]));
-	for (const [key, value] of Object.entries(config)) {
-		const field = fields.get(key);
-		if (!field) throw new Error(`Plugin field is not declared for management: ${key}`);
-		if (field.input === "number") {
-			if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || field.minimum !== void 0 && value < field.minimum || field.maximum !== void 0 && value > field.maximum) throw new Error(`Invalid numeric plugin field: ${key}`);
-		} else if (field.input === "source-list" || field.input === "string-list") {
-			if (!Array.isArray(value) || value.length > 32 || value.some((item) => typeof item !== "string" || !item.trim() || item.length > 500) || new Set(value).size !== value.length) throw new Error(`Invalid plugin list: ${key}`);
-		} else if (typeof value !== "string" || value.length > (field.maximum ?? 4e3)) throw new Error(`Invalid plugin text: ${key}`);
-	}
-	return config;
-}
-function validateEditor(definition) {
-	const text = (value) => typeof value === "object" && value !== null && ["en", "zh-CN"].every((key) => {
-		const item = value[key];
-		return typeof item === "string" && item.trim() !== "" && item.length <= 4e3;
-	});
-	if (definition.apiVersion !== "dsh-mnemon/strategy-configuration/v1" || typeof definition.create !== "function" || !["strategy", "strategy-extension"].includes(definition.kind) || !/^[a-z][a-z0-9-]{0,127}$/u.test(definition.typeId) || !Array.isArray(definition.fields) || definition.fields.length > 16 || new Set(definition.fields.map((field) => field.key)).size !== definition.fields.length || definition.fields.some((field) => !/^[a-zA-Z][a-zA-Z0-9]{0,99}$/u.test(field.key) || ![
-		"number",
-		"text",
-		"textarea",
-		"string-list",
-		"source-list"
-	].includes(field.input) || !text(field.label) || field.description !== void 0 && !text(field.description) || [field.minimum, field.maximum].some((bound) => bound !== void 0 && (typeof bound !== "number" || !Number.isFinite(bound))) || field.sourceRoles !== void 0 && (!Array.isArray(field.sourceRoles) || field.sourceRoles.length > 32 || field.sourceRoles.some((role) => typeof role !== "string" || !role || role.length > 128))) || !text(definition.label) || !text(definition.description)) throw new Error("Invalid plugin configuration descriptor");
-	if (canonicalMemoryJson({
-		label: definition.label,
-		description: definition.description,
-		fields: definition.fields
-	}, "Plugin editor metadata").length > 65536) throw new Error("Plugin editor metadata exceeds 64 KiB");
-	for (const field of definition.fields) if (field.defaultValue !== void 0) configuration(definition, { [field.key]: field.defaultValue });
-}
 function contributionRoles(snapshot, entryId) {
 	const roles = /* @__PURE__ */ new Set();
 	if (snapshot.sources.some((value) => value.provenance.entryId === entryId)) roles.add("source");
@@ -7531,9 +7642,8 @@ function fallbackDescriptor(entry, snapshot, editor) {
 }
 function prepared(item, config) {
 	if (item.editor === void 0) throw new Error(`Plugin does not expose a pure configuration factory: ${item.entry.id}`);
-	const contribution = item.editor.create(configuration(item.editor, config));
-	const values = [...contribution.strategies ?? [], ...contribution.strategyExtensions ?? []];
-	if (values.length !== 1 || values[0].manifest.typeId !== item.editor.typeId || values[0].manifest.kind !== item.editor.kind || values[0].manifest.packageName !== item.entry.options.name) throw new Error("Plugin factory does not match its declared Entry");
+	const contribution = item.editor.create(config);
+	if ([...contribution.strategies ?? [], ...contribution.strategyExtensions ?? []][0].manifest.packageName !== item.entry.options.name) throw new Error("Plugin factory does not match its declared Entry");
 	if (contribution.plugin !== void 0 && hash(contribution.plugin) !== hash(item.descriptor)) throw new Error("Plugin factory descriptor does not match its module export");
 	return prepareMemoryContributions({
 		...contribution,
@@ -7671,8 +7781,7 @@ var MemoryPluginManagement = class {
 			try {
 				let module = entry.fiber?.runtime?.callback;
 				if (!module?.memoryPlugin && !module?.memoryStrategyConfiguration) module = await entry.parent.tree.import(entry.options.name);
-				const editor = module?.memoryStrategyConfiguration;
-				if (editor !== void 0) validateEditor(editor);
+				const editor = module?.memoryStrategyConfiguration === void 0 ? void 0 : readMemoryStrategyConfiguration(module.memoryStrategyConfiguration);
 				const registeredDescriptor = snapshot.plugins?.find((plugin) => plugin.provenance.entryId === entry.id)?.descriptor;
 				const descriptor = defineMemoryPlugin(module?.memoryPlugin ?? registeredDescriptor ?? fallbackDescriptor(entry, snapshot, editor));
 				if (descriptor.packageName !== entry.options.name) throw new Error("Plugin descriptor package does not match its Loader Entry");
@@ -7701,7 +7810,7 @@ var MemoryPluginManagement = class {
 					requires: [...descriptor.requires ?? []],
 					requiredBy: [],
 					fields: editor?.fields ?? [],
-					config: editor === void 0 ? {} : configuration(editor, entry.options.config),
+					config: editor === void 0 ? {} : memoryStrategyConfigurationValues(editor, entry.options.config),
 					enabled: !entry.disabled,
 					active,
 					writable: this.ctx.settings.writable && !ancestorDisabled && (entry.options.disabled === void 0 || typeof entry.options.disabled === "boolean"),