dsh-mnemon-source-memory-spaces 0.5.18 → 0.5.20

package/lib/index.js

@@ -1,7 +1,7 @@
 import { findMnemonCommand, isMnemonExecutable, resolveMnemonInvocation } from "./native-cli.js";
 import { CATEGORIES as CATEGORIES$1, EDGE_TYPES, INTENTS as INTENTS$1, MNEMON_EMBEDDING_PROTOCOLS, SOURCES as SOURCES$1, normalizeEntityKey } from "./contracts.js";
 import { a as MemoryProviderCatalog, i as EMPTY_MEMORY_PROVIDER_CATALOG, n as PrivateMemorySpaceProviderHost, r as MemoryProviderAdapterRegistry, t as createMemorySpaceProviderPlugin } from "./plugin-DlsNeZbQ.js";
-import { n as ProcessError, r as runProcess } from "./process-DIK9NnTg.js";
+import { i as runProcess, r as ProcessError } from "./adapter-D-BnWkko.js";
 import { r as defineMemorySpaceProvider } from "./definitions-DfmOqJjR.js";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
@@ -43,6 +43,7 @@ function modelSpaceCatalog(catalog) {
 function modelStatus(status) {
 	const active = status.memoryBodies.filter((body) => body.active && body.providerEnabled !== false);
 	const unhealthy = active.filter((body) => !body.healthy);
+	const summed = active.filter((body) => body.healthy && body.stats !== void 0);
 	const relevantProviders = status.providerServices?.filter((provider) => provider.enabled || provider.configured || provider.memoryBodyCount > 0 || provider.status === "unhealthy") ?? [];
 	const providers = relevantProviders.slice(0, 16);
 	const providerReady = status.commandFound === true || (status.providerServices ?? []).some((provider) => provider.enabled && provider.configured);
@@ -73,6 +74,8 @@ function modelStatus(status) {
 		})),
 		omittedProviderCount: Math.max(0, relevantProviders.length - providers.length),
 		...status.stats === void 0 ? {} : { aggregate: {
+			scope: "Sums over the active, healthy Memory Spaces whose Provider reports statistics (spaces); the others add nothing. totalInsights counts live memories, and deletedInsights the forgotten ones a Provider keeps, as Mnemon Native does.",
+			spaces: summed.length,
 			totalInsights: status.stats.totalInsights,
 			deletedInsights: status.stats.deletedInsights,
 			edgeCount: status.stats.edgeCount,
@@ -103,9 +106,40 @@ const NATIVE_REGISTRY_VERSION = 1;
 const PROVIDER_REGISTRY_VERSION = 4;
 const ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
 const PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]{0,127}$/u;
+const DISCONNECTS_VERSION = 1;
+/** Settings whose value can name a namespace: a bank, workspace, user, tag, URI or folder. */
+const IDENTITY_INPUTS = /* @__PURE__ */ new Set([
+	"text",
+	"url",
+	"path"
+]);
 function storedProviderId(value) {
 	return typeof value === "string" && PROVIDER_ID_PATTERN.test(value);
 }
+/** Disconnected namespaces as a file holds them: sound entries only, newest last. */
+function storedDisconnects(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => {
+		if (typeof item !== "object" || item === null || Array.isArray(item)) return [];
+		const fields = item;
+		const externalId = typeof fields.externalId === "string" && fields.externalId.trim() !== "" && fields.externalId.trim().length <= 2e3 ? fields.externalId.trim() : void 0;
+		const connection = storedProviderConnection(fields.connection);
+		const entry = {
+			...externalId === void 0 ? {} : { externalId },
+			...Object.keys(connection).length === 0 ? {} : { connection }
+		};
+		return Object.keys(entry).length === 0 ? [] : [entry];
+	}).slice(-1e3);
+}
+/** JSON with every object's keys in order, so two equal connections compare equal. */
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value !== null && typeof value === "object") {
+		const fields = value;
+		return `{${Object.keys(fields).filter((key) => fields[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(fields[key])}`).join(",")}}`;
+	}
+	return JSON.stringify(value) ?? "null";
+}
 function storedProviderConnection(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
 	return Object.fromEntries(Object.entries(value).filter((entry) => {
@@ -216,6 +250,8 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 	directory;
 	registryPath;
 	providerRegistryPath;
+	/** The namespaces a person disconnected, which asking a Provider again leaves out (#373). */
+	disconnectsPath;
 	refreshing = false;
 	state;
 	constructor(runner, persistent = true, now = () => /* @__PURE__ */ new Date(), providerCatalog = EMPTY_MEMORY_PROVIDER_CATALOG, sharedState) {
@@ -226,11 +262,13 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 		this.state = sharedState ?? {
 			spaces: [],
 			services: {},
-			serviceEnabled: {}
+			serviceEnabled: {},
+			disconnected: {}
 		};
 		this.directory = join(runner.effectiveDataDir(), "data");
 		this.registryPath = join(this.directory, ".dsh-memory-bodies.json");
 		this.providerRegistryPath = join(runner.effectiveDataDir(), "state", "memory-providers.json");
+		this.disconnectsPath = join(runner.effectiveDataDir(), "state", "memory-provider-disconnects.json");
 		if (sharedState === void 0) this.reload();
 	}
 	get spaces() {
@@ -251,6 +289,12 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 	set serviceEnabled(value) {
 		this.state.serviceEnabled = value;
 	}
+	get disconnected() {
+		return this.state.disconnected;
+	}
+	set disconnected(value) {
+		this.state.disconnected = value;
+	}
 	/** One generation-local descriptor view over the same persistent authority. */
 	withProviderCatalog(providerCatalog) {
 		return new MemorySpaceRegistry(this.runner, this.persistent, this.now, providerCatalog, this.state);
@@ -400,8 +444,181 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 		this.serviceEnabled[providerId] = true;
 		this.spaces = [...this.spaces.filter((body) => body.providerId !== providerId), ...projections];
 		this.save();
+		this.forgetDisconnected(providerId, this.reportedNamespaces(providerId, normalizedService, discovered));
 		return this.providerServices().items.find((item) => item.providerId === providerId);
 	}
+	/**
+	* Mount the namespaces a Provider reports that this directory has never held, as asking a
+	* Provider again finds them (#373). A space already mounted is left exactly as it is, and so is
+	* a namespace a person disconnected. A new space starts inactive: recall reads it only once a
+	* person turns it on. A space counts as a reported namespace when it has its externalId, or the
+	* settings that name it (see `holds`): a space made by hand for the same bank, or one whose
+	* externalId the Provider now writes differently. A Provider switched off, or saved with other
+	* settings since `service` was read, gets nothing: that save decides. Nothing is written when
+	* nothing is new.
+	*/
+	mountDiscovered(providerId, service, discovered) {
+		this.refreshIfChanged();
+		if (this.isNative(providerId)) throw new Error("Mnemon Native Stores are discovered from disk");
+		const current = this.services[providerId];
+		if (current === void 0 || !this.providerServiceEnabled(providerId) || canonicalJson(current) !== canonicalJson(this.providerCatalog.normalizeService(providerId, service))) return {
+			added: [],
+			disconnected: 0
+		};
+		const held = this.spaces.filter((body) => body.providerId === providerId).map((body) => ({
+			...body.externalId === void 0 ? {} : { externalId: body.externalId },
+			...body.connection === void 0 ? {} : { connection: body.connection }
+		}));
+		const disconnected = this.disconnected[providerId] ?? [];
+		const reservedIds = new Set(this.spaces.map((body) => body.id));
+		const timestamp = this.now().toISOString();
+		const added = [];
+		let stillDisconnected = 0;
+		for (const reported of this.reportedNamespaces(providerId, current, discovered)) {
+			if (held.some((body) => this.holds(providerId, current, body, reported)) || added.some((body) => body.externalId === reported.externalId)) continue;
+			if (disconnected.some((entry) => this.holds(providerId, current, entry, reported))) {
+				stillDisconnected += 1;
+				continue;
+			}
+			const { externalId, connection, candidate } = reported;
+			let id = validateMemorySpaceId(`${providerId}-${createHash("sha256").update(externalId).digest("hex").slice(0, 24)}`);
+			let suffix = 1;
+			while (reservedIds.has(id)) {
+				id = validateMemorySpaceId(`${providerId}-${createHash("sha256").update(`${externalId}:${suffix}`).digest("hex").slice(0, 24)}`);
+				suffix += 1;
+			}
+			const metadata = providerProjectionMetadata(this.providerCatalog, providerId, candidate);
+			added.push({
+				id,
+				externalId,
+				name: metadata.name,
+				description: metadata.description,
+				metadataSource: "provider",
+				active: false,
+				providerId,
+				connection,
+				createdAt: timestamp,
+				updatedAt: timestamp
+			});
+			reservedIds.add(id);
+		}
+		if (added.length > 0) {
+			this.spaces = [...this.spaces, ...added];
+			this.save();
+		}
+		return {
+			added: added.map((body) => this.view(body)),
+			disconnected: stillDisconnected
+		};
+	}
+	/** The namespaces in one Provider answer this directory could hold; the others are left out. */
+	reportedNamespaces(providerId, service, discovered) {
+		const reported = discovered.flatMap((candidate) => {
+			try {
+				const externalId = requiredText(candidate.externalId, "provider externalId", 2e3);
+				const connection = this.providerCatalog.normalizeMemory(providerId, candidate.connection);
+				this.providerCatalog.normalize(providerId, {
+					...service,
+					...connection
+				});
+				const identity = this.namespaceIdentity(providerId, connection);
+				const whole = identity === void 0 ? this.wholeConnection(providerId, service, connection) : void 0;
+				return [{
+					candidate,
+					externalId,
+					connection,
+					...identity === void 0 ? {} : { identity },
+					...whole === void 0 ? {} : { whole },
+					distinct: false
+				}];
+			} catch {
+				return [];
+			}
+		});
+		const signature = (namespace) => namespace.identity !== void 0 ? `identity:${canonicalJson(namespace.identity)}` : namespace.whole === void 0 ? void 0 : `connection:${namespace.whole}`;
+		const counts = /* @__PURE__ */ new Map();
+		for (const namespace of reported) {
+			const key = signature(namespace);
+			if (key !== void 0) counts.set(key, (counts.get(key) ?? 0) + 1);
+		}
+		for (const namespace of reported) {
+			const key = signature(namespace);
+			namespace.distinct = key !== void 0 && counts.get(key) === 1;
+		}
+		return reported;
+	}
+	/**
+	* What names a namespace in a space's own settings: each text, address or path set for it. A
+	* wildcard (`*`) names nothing, and neither does a choice, a switch, a number such as a recall
+	* budget or a trust floor, or a secret.
+	*/
+	namespaceIdentity(providerId, connection) {
+		if (connection === void 0) return void 0;
+		const identity = {};
+		for (const field of this.providerCatalog.memoryFields(providerId)) {
+			if (!IDENTITY_INPUTS.has(field.input)) continue;
+			const value = connection[field.key];
+			if (typeof value !== "string") continue;
+			const text = value.trim();
+			if (text === "" || text === "*") continue;
+			identity[field.key] = text;
+		}
+		return Object.keys(identity).length === 0 ? void 0 : identity;
+	}
+	/** A whole connection, defaults filled in; one whose own part is empty compares by externalId alone. */
+	wholeConnection(providerId, service, memory) {
+		if (memory === void 0 || Object.keys(memory).length === 0) return void 0;
+		try {
+			return canonicalJson(this.providerCatalog.normalize(providerId, {
+				...service,
+				...memory
+			}));
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Whether `held`, a mounted space or a namespace a person disconnected, already reads the
+	* namespace a Provider reported: the same externalId, or every setting that names the namespace,
+	* whatever else differs; a `*` held reads every value. A hand-made Hindsight space for bank
+	* `team` with another recall budget reads bank `team`; a Honcho space for one peer of workspace
+	* `w1` reads workspace `w1`. Asking again only adds what nothing here reads yet.
+	*/
+	holds(providerId, service, held, reported) {
+		if (held.externalId !== void 0 && held.externalId === reported.externalId) return true;
+		if (!reported.distinct || held.connection === void 0) return false;
+		if (reported.identity !== void 0) {
+			const connection = held.connection;
+			return Object.entries(reported.identity).every(([key, value]) => {
+				const setting = connection[key];
+				return typeof setting === "string" && (setting.trim() === value || setting.trim() === "*");
+			});
+		}
+		return reported.whole !== void 0 && this.wholeConnection(providerId, service, held.connection) === reported.whole;
+	}
+	/** Remember a namespace a person disconnected, so asking its Provider again leaves it out. */
+	rememberDisconnected(providerId, body) {
+		const connection = body.connection === void 0 ? {} : this.providerCatalog.publicScoped(providerId, "memory", body.connection).settings;
+		const entry = {
+			...body.externalId === void 0 ? {} : { externalId: body.externalId },
+			...Object.keys(connection).length === 0 ? {} : { connection }
+		};
+		if (Object.keys(entry).length === 0) return;
+		const key = canonicalJson(entry);
+		this.disconnected[providerId] = [...(this.disconnected[providerId] ?? []).filter((item) => canonicalJson(item) !== key), entry].slice(-1e3);
+		this.saveDisconnects();
+	}
+	/** Forget the disconnected namespaces a save of the Provider's settings mounted again. */
+	forgetDisconnected(providerId, reported) {
+		const remembered = this.disconnected[providerId];
+		if (remembered === void 0) return;
+		const service = this.services[providerId] ?? {};
+		const remaining = remembered.filter((entry) => !reported.some((namespace) => this.holds(providerId, service, entry, namespace)));
+		if (remaining.length === remembered.length) return;
+		if (remaining.length === 0) delete this.disconnected[providerId];
+		else this.disconnected[providerId] = remaining;
+		this.saveDisconnects();
+	}
 	placementCandidates(request) {
 		return this.providerCatalog.providers.map((descriptor) => {
 			const providerTypeId = descriptor.typeId ?? descriptor.id;
@@ -556,8 +773,10 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 	async remove(id, signal) {
 		const body = this.get(id);
 		if (!this.isNative(body.provider.id)) {
+			const stored = this.spaces.find((entry) => entry.id === body.id);
 			this.spaces = this.spaces.filter((entry) => entry.id !== body.id);
 			this.save();
+			if (stored !== void 0) this.rememberDisconnected(body.provider.id, stored);
 			return body;
 		}
 		const nativeStoreIds = this.nativeStoreIds();
@@ -621,6 +840,7 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 			this.spaces = [];
 			this.services = {};
 			this.serviceEnabled = {};
+			this.disconnected = {};
 			this.loadAndReconcile();
 			this.state.diskRevision = this.diskRevision();
 		} finally {
@@ -629,7 +849,11 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 	}
 	diskRevision() {
 		if (!this.persistent) return "ephemeral";
-		return [this.registryPath, this.providerRegistryPath].map((path) => {
+		return [
+			this.registryPath,
+			this.providerRegistryPath,
+			this.disconnectsPath
+		].map((path) => {
 			try {
 				const stat = statSync(path, { bigint: true });
 				return `${stat.ino}:${stat.mtimeNs}:${stat.size}`;
@@ -748,6 +972,13 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 				}));
 			}
 		} catch {}
+		if (this.persistent && existsSync(this.disconnectsPath)) try {
+			const parsed = JSON.parse(readFileSync(this.disconnectsPath, "utf8"));
+			if (parsed.version === DISCONNECTS_VERSION && typeof parsed.providers === "object" && parsed.providers !== null) for (const [providerId, entries] of Object.entries(parsed.providers)) {
+				const remembered = storedDisconnects(entries);
+				if (storedProviderId(providerId) && remembered.length > 0) this.disconnected[providerId] = remembered;
+			}
+		} catch {}
 		const retainedBodies = this.spaces.filter((body) => !this.providerCatalog.has(body.providerId) || this.isNative(body.providerId) || this.providerServiceEnabled(body.providerId));
 		if (retainedBodies.length !== this.spaces.length) {
 			this.spaces = retainedBodies;
@@ -849,6 +1080,22 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 		});
 		this.state.diskRevision = this.diskRevision();
 	}
+	saveDisconnects() {
+		if (!this.persistent) return;
+		const providers = Object.fromEntries(Object.entries(this.disconnected).filter(([, entries]) => entries !== void 0 && entries.length > 0));
+		if (Object.keys(providers).length === 0) rmSync(this.disconnectsPath, { force: true });
+		else {
+			mkdirSync(dirname(this.disconnectsPath), {
+				recursive: true,
+				mode: 448
+			});
+			this.writeRegistry(this.disconnectsPath, {
+				version: DISCONNECTS_VERSION,
+				providers
+			});
+		}
+		this.state.diskRevision = this.diskRevision();
+	}
 	writeRegistry(path, file) {
 		const temporary = join(dirname(path), `.${basename(path)}.${process.pid}.tmp`);
 		writeFileSync(temporary, `${JSON.stringify(file, null, 2)}\n`, {
@@ -859,6 +1106,132 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 	}
 };
 //#endregion
+//#region src/runner.ts
+var MnemonCliError = class extends Error {
+	reason;
+	constructor(message, reason) {
+		super(message);
+		this.reason = reason;
+		this.name = "MnemonCliError";
+	}
+};
+const EMBEDDING_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
+	"MNEMON_EMBED_ENDPOINT",
+	"MNEMON_EMBED_MODEL",
+	"MNEMON_EMBED_API_KEY",
+	"MNEMON_EMBED_PROTOCOL"
+]);
+/**
+* Explain a CLI call that produced no result. Only a failed launch means the
+* executable is missing or unusable, so only that case carries the install
+* hint; a timeout, a cancellation or an oversized output names its own cause.
+*/
+function processFailureMessage(error, args) {
+	const detail = error instanceof Error ? error.message : String(error);
+	const reason = error instanceof ProcessError ? error.reason : "launch";
+	const command = args.find((arg) => !arg.startsWith("-"));
+	if (reason === "output-limit") return `mnemon ${command ?? "command"} stopped: ${detail.replace(/^mnemon /u, "")}`;
+	if (reason === "timeout" && command !== void 0) return detail.replace(/^mnemon /u, `mnemon ${command} `);
+	if (reason !== "launch") return detail;
+	return `${detail}. ${process.platform === "win32" ? "Install the official Mnemon Windows release, ensure mnemon.exe is on PATH or under %LOCALAPPDATA%\\Programs\\mnemon, or set MNEMON_CLI_PATH or mnemon.cliPath to its absolute path." : "Install Mnemon and ensure \"mnemon\" is on PATH, or set MNEMON_CLI_PATH or mnemon.cliPath."}`;
+}
+/** Preserve the Host environment while making saved embedding overrides authoritative. */
+function processEnvironment(config) {
+	if (!config.embedding.enabled) return void 0;
+	return {
+		...Object.fromEntries(Object.entries(process.env).filter(([key]) => !EMBEDDING_ENVIRONMENT_KEYS.has(key.toUpperCase()))),
+		MNEMON_EMBED_ENDPOINT: config.embedding.endpoint,
+		MNEMON_EMBED_MODEL: config.embedding.model,
+		MNEMON_EMBED_API_KEY: config.embedding.apiKey,
+		...config.embedding.protocol === "auto" ? {} : { MNEMON_EMBED_PROTOCOL: config.embedding.protocol }
+	};
+}
+function createRunner(config, processRunner = runProcess) {
+	const currentCommand = () => findMnemonCommand(config) ?? config.cliPath ?? "mnemon";
+	const globalArgs = (store) => {
+		const args = ["--data-dir", effectiveDataDir()];
+		if (store !== void 0) args.push("--store", store);
+		else if (config.store !== void 0) args.push("--store", config.store);
+		return args;
+	};
+	const effectiveDataDir = () => config.dataDir;
+	const persistedStore = () => {
+		const active = join(effectiveDataDir(), "active");
+		if (existsSync(active)) try {
+			const value = readFileSync(active, "utf8").trim();
+			if (/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value)) return value;
+		} catch {}
+		return "default";
+	};
+	const launch = async (args, options = {}) => {
+		if (options.signal?.aborted === true) throw new MnemonCliError(`mnemon command aborted: ${String(options.signal.reason ?? "cancelled")}`, "aborted");
+		if (options.database !== void 0 && !existsSync(options.database)) throw new MnemonCliError(`mnemon ${args.find((arg) => !arg.startsWith("-")) ?? "command"}: no database at ${options.database}`, "no-database");
+		const argv = options.globalFlags === false ? [...args] : [...globalArgs(options.store), ...args];
+		const environment = processEnvironment(config);
+		const processOptions = {
+			timeoutMs: options.timeoutMs ?? config.timeoutMs,
+			...environment === void 0 ? {} : { env: environment },
+			...options.signal === void 0 ? {} : { signal: options.signal },
+			...options.maxOutputBytes === void 0 ? {} : { maxOutputBytes: options.maxOutputBytes }
+		};
+		let result;
+		try {
+			const invocation = resolveMnemonInvocation(currentCommand(), argv, environment);
+			result = await processRunner(invocation.command, invocation.args, {
+				...processOptions,
+				...invocation.env === void 0 ? {} : { env: invocation.env }
+			});
+		} catch (error) {
+			throw new MnemonCliError(processFailureMessage(error, args), error instanceof ProcessError ? error.reason : "launch");
+		}
+		if (result.exitCode !== 0) {
+			const detail = result.stderr.trim() || result.stdout.trim() || "no output";
+			throw new MnemonCliError(`mnemon ${args.join(" ")} exited ${String(result.exitCode)}: ${detail}`);
+		}
+		return result.stdout;
+	};
+	const execute = (args, options = {}) => {
+		return withMemoryStorageLock(effectiveDataDir(), () => launch(args, options));
+	};
+	return {
+		get command() {
+			return currentCommand();
+		},
+		get commandFound() {
+			const found = findMnemonCommand(config);
+			return found !== void 0 && isMnemonExecutable(found);
+		},
+		async runJson(args, options) {
+			const stdout = await execute(args, options);
+			try {
+				return JSON.parse(stdout);
+			} catch {
+				throw new MnemonCliError(`mnemon ${args.join(" ")} returned invalid JSON`);
+			}
+		},
+		runText: execute,
+		runTextBatch(commands) {
+			return withMemoryStorageLock(effectiveDataDir(), async () => {
+				const outputs = [];
+				for (const command of commands) outputs.push(await launch(command.args, command.options));
+				return outputs;
+			});
+		},
+		effectiveDataDir() {
+			return effectiveDataDir();
+		},
+		persistedStore() {
+			return persistedStore();
+		},
+		effectiveStore() {
+			if (config.store !== void 0) return config.store;
+			const fromEnvironment = process.env.MNEMON_STORE?.trim();
+			if (fromEnvironment !== void 0 && fromEnvironment !== "") return fromEnvironment;
+			return persistedStore();
+		}
+	};
+}
+//#endregion
 //#region src/provider-placement.ts
 const CAPABILITY_LABELS = {
 	graph: "typed graph",
@@ -1300,6 +1673,25 @@ function number(value) {
 const ENTITY_SELECTION_STATUS_REUSE_MS = 1e4;
 /** How long an index that statistics cannot check is reused; a write through this Source still drops it. */
 const ENTITY_INDEX_UNCHECKED_REUSE_MS = 1e4;
+/** How long one Provider may take to list its namespaces when they are asked for again. */
+const MEMORY_SPACES_REDISCOVERY_PROVIDER_TIMEOUT_MS = 3e4;
+/**
+* Rediscovery per data directory, shared by every generation in this process: the pass now
+* running, which a second request joins, and the last one, which the Memory Spaces page shows.
+*/
+const rediscoveries = /* @__PURE__ */ new Map();
+/** Settle with `work`, or reject once `signal` aborts, whichever comes first. */
+function untilAborted(work, signal) {
+	if (signal.aborted) {
+		work.catch(() => {});
+		return Promise.reject(signal.reason);
+	}
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		work.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+	});
+}
 function entityName(entity) {
 	const name = entity.trim();
 	if (name.length > 200) throw new Error("entity is too long (max 200 characters)");
@@ -1486,6 +1878,41 @@ function mutationResultCompletion(result) {
 function mutationResultCommitted(result) {
 	return mutationResultCompletion(result) === "committed";
 }
+/** One `mnemon embed --status` answer, strictly validated. */
+function embeddingCounts(value) {
+	const output = record(value);
+	const available = output?.embedding_available ?? output?.ollama_available;
+	const model = text(output?.model)?.trim();
+	const protocol = text(output?.protocol)?.trim();
+	const totalInsights = number(output?.total_insights);
+	const embedded = number(output?.embedded);
+	const coverage = text(output?.coverage)?.trim();
+	if (typeof available !== "boolean" || model === void 0 || model === "" || model.length > 200 || /[\u0000-\u001f\u007f]/u.test(model) || !Number.isInteger(totalInsights) || totalInsights < 0 || !Number.isInteger(embedded) || embedded < 0 || embedded > totalInsights || coverage === void 0 || !/^(?:100|\d{1,2})%$/u.test(coverage)) throw new Error("mnemon embed --status returned an invalid response");
+	return {
+		available,
+		model,
+		totalInsights,
+		embedded,
+		coverage,
+		...protocol !== void 0 && protocol.length <= 32 && !/[\u0000-\u001f\u007f]/u.test(protocol) ? { protocol } : {}
+	};
+}
+/** How long one fill of a space's vectors may run, and the longest step of it that holds the storage lock (#392). */
+const EMBED_FILL_BUDGET_MS = 6e4;
+const EMBED_FILL_STEP_MS = 1e4;
+/** A whole percent, as Mnemon writes it, that reads 100% only when every memory has its vector. */
+function coveragePercent(embedded, total) {
+	return total === 0 ? "0%" : `${Math.floor(embedded * 100 / total)}%`;
+}
+/** Mnemon's reason for a failed call, without the usage it prints after its `Error:` line. */
+function cliReason(error) {
+	const detail = error instanceof Error ? error.message : String(error);
+	return /\bError: ([^\n]+)/u.exec(detail)?.[1]?.trim() ?? detail.split("\n")[0].trim();
+}
+/** Whether a CLI call failed for this cause. */
+function cliFailure(error, reason) {
+	return error instanceof MnemonCliError && error.reason === reason;
+}
 var MemorySpacesService = class {
 	runner;
 	config;
@@ -1624,7 +2051,15 @@ var MemorySpacesService = class {
 			total: items.length,
 			activeCount: items.filter((body) => body.active && body.providerEnabled !== false).length,
 			directory: this.memorySpaces.directory,
-			generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			rediscovery: this.rediscoveryState()
+		};
+	}
+	rediscoveryState() {
+		const entry = rediscoveries.get(this.memorySpaces.providerRegistryPath);
+		return {
+			running: entry?.running !== void 0,
+			...entry?.last === void 0 ? {} : { last: entry.last }
 		};
 	}
 	/** Stable, secret-free checkpoint for the projected Memory Space authority. */
@@ -1702,23 +2137,137 @@ var MemorySpacesService = class {
 			...version === void 0 ? {} : { version }
 		};
 	}
-	/** Probe the effective Mnemon embedding runtime and its default Store coverage. */
+	/**
+	* Probe Mnemon's embedding runtime, and count the vectors of every Mnemon Native space:
+	* `mnemon embed --status` counts only one Store, so a full count for it could read as the
+	* health of every space while another one lacked vectors (#392).
+	*/
 	async embeddingStatus(signal) {
-		const output = record(await this.runner.runJson(["embed", "--status"], signal === void 0 ? {} : { signal }));
-		const available = output?.embedding_available ?? output?.ollama_available;
-		const model = text(output?.model)?.trim();
-		const protocol = text(output?.protocol)?.trim();
-		const totalInsights = number(output?.total_insights);
-		const embedded = number(output?.embedded);
-		const coverage = text(output?.coverage)?.trim();
-		if (typeof available !== "boolean" || model === void 0 || model === "" || model.length > 200 || /[\u0000-\u001f\u007f]/u.test(model) || !Number.isInteger(totalInsights) || totalInsights < 0 || !Number.isInteger(embedded) || embedded < 0 || embedded > totalInsights || coverage === void 0 || !/^(?:100|\d{1,2})%$/u.test(coverage)) throw new Error("mnemon embed --status returned an invalid response");
+		const native = this.memorySpaces.list().filter((body) => this.isNativeSpace(body) && existsSync(body.dbPath));
+		let runtime;
+		const spaces = [];
+		for (const body of native) {
+			const space = {
+				memoryBodyId: body.id,
+				name: body.name,
+				active: body.active
+			};
+			try {
+				const counts = embeddingCounts(await this.runner.runJson(["embed", "--status"], {
+					store: body.id,
+					database: body.dbPath,
+					...signal === void 0 ? {} : { signal }
+				}));
+				runtime ??= counts;
+				spaces.push({
+					...space,
+					totalInsights: counts.totalInsights,
+					embedded: counts.embedded,
+					coverage: coveragePercent(counts.embedded, counts.totalInsights)
+				});
+			} catch (error) {
+				if (signal?.aborted === true) throw error;
+				if (cliFailure(error, "no-database")) continue;
+				spaces.push({
+					...space,
+					totalInsights: 0,
+					embedded: 0,
+					coverage: "0%",
+					error: cliReason(error)
+				});
+			}
+		}
+		runtime ??= await this.embeddingRuntime(signal);
+		const counted = spaces.filter((space) => space.error === void 0);
+		const totalInsights = counted.reduce((sum, space) => sum + space.totalInsights, 0);
+		const embedded = counted.reduce((sum, space) => sum + space.embedded, 0);
 		return {
-			available,
-			model,
+			...runtime,
 			totalInsights,
 			embedded,
-			coverage,
-			...protocol !== void 0 && protocol.length <= 32 && !/[\u0000-\u001f\u007f]/u.test(protocol) ? { protocol } : {}
+			coverage: coveragePercent(embedded, totalInsights),
+			spaces
+		};
+	}
+	/** Mnemon's embedding runtime, asked in a scratch data directory: no space could be counted, and Mnemon creates the Store it opens. */
+	async embeddingRuntime(signal) {
+		const directory = mkdtempSync(join(tmpdir(), "dsh-mnemon-embedding-"));
+		try {
+			return embeddingCounts(await this.runner.runJson([
+				"--data-dir",
+				directory,
+				"embed",
+				"--status"
+			], {
+				globalFlags: false,
+				...signal === void 0 ? {} : { signal }
+			}));
+		} catch (error) {
+			throw new Error(cliReason(error), { cause: error });
+		} finally {
+			rmSync(directory, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	/**
+	* Fill in the vectors a Mnemon Native space lacks, through the Host's own data directory and
+	* embedding settings, which a terminal `mnemon embed --all` may not share (#392). Mnemon fills at
+	* most 100 a call and keeps the vectors it wrote when a call is stopped, so the fill goes in steps
+	* no longer than one CLI call, letting other memory work take the storage lock between them,
+	* until none is missing, a step writes none, or a minute is up.
+	*/
+	async embedMissing(memoryBodyId, signal) {
+		this.assertWritable();
+		const body = this.memorySpaces.get(validateMemorySpaceId(memoryBodyId));
+		if (!this.isNativeSpace(body)) throw new Error(`${body.provider.label} keeps no Mnemon vectors to fill in`);
+		const options = {
+			store: body.id,
+			database: body.dbPath,
+			...signal === void 0 ? {} : { signal }
+		};
+		const failed = (error) => new Error(cliFailure(error, "no-database") ? `Memory Space ${body.name} has no database` : cliReason(error), { cause: error });
+		const count = async () => {
+			try {
+				return embeddingCounts(await this.runner.runJson(["embed", "--status"], options));
+			} catch (error) {
+				throw failed(error);
+			}
+		};
+		const step = Math.min(this.config.timeoutMs, EMBED_FILL_STEP_MS);
+		const deadline = Date.now() + EMBED_FILL_BUDGET_MS;
+		const first = await count();
+		let last = first;
+		let stopped;
+		while (last.embedded < last.totalInsights) {
+			if (Date.now() + step > deadline) {
+				stopped = "time";
+				break;
+			}
+			try {
+				await this.runner.runText(["embed", "--all"], {
+					...options,
+					timeoutMs: step
+				});
+			} catch (error) {
+				if (!cliFailure(error, "timeout")) throw failed(error);
+			}
+			const next = await count();
+			const progressed = next.embedded > last.embedded;
+			last = next;
+			if (!progressed) {
+				stopped = "refused";
+				break;
+			}
+		}
+		const remaining = last.totalInsights - last.embedded;
+		return {
+			memoryBodyId: body.id,
+			filled: Math.max(0, last.embedded - first.embedded),
+			remaining,
+			model: last.model,
+			...remaining > 0 && stopped !== void 0 ? { stopped } : {}
 		};
 	}
 	async status(signal) {
@@ -2509,6 +3058,89 @@ var MemorySpacesService = class {
 		const discovered = await provider.discover(connection, signal);
 		return this.memorySpaces.syncProviderService(providerId, connection, discovered);
 	}
+	/**
+	* Ask every enabled Provider service again for its namespaces, as saving its settings does, and
+	* mount the ones this directory has never held, inactive (#373). Nothing mounted changes and a
+	* namespace a person disconnected stays disconnected. Providers are asked side by side, each
+	* for at most 30 seconds; one that cannot answer keeps its spaces and says why. A pass already
+	* running for this directory, at start-up or from the page, is joined rather than run twice; a
+	* request that joined one its starter then stopped asks again, unless it was stopped itself.
+	*/
+	async rediscoverProviders(trigger, signal, providerTimeoutMs = MEMORY_SPACES_REDISCOVERY_PROVIDER_TIMEOUT_MS) {
+		this.assertWritable();
+		const key = this.memorySpaces.providerRegistryPath;
+		const entry = rediscoveries.get(key) ?? {};
+		rediscoveries.set(key, entry);
+		const joined = entry.running;
+		if (joined !== void 0) try {
+			return await (signal === void 0 ? joined : untilAborted(joined, signal));
+		} catch {
+			signal?.throwIfAborted();
+			const next = entry.running;
+			if (next !== void 0 && next !== joined) return await (signal === void 0 ? next : untilAborted(next, signal));
+		}
+		const running = this.runRediscovery(trigger, signal, providerTimeoutMs);
+		entry.running = running;
+		try {
+			const outcome = await running;
+			entry.last = outcome;
+			return outcome;
+		} finally {
+			if (entry.running === running) delete entry.running;
+		}
+	}
+	async runRediscovery(trigger, signal, providerTimeoutMs) {
+		const services = this.memorySpaces.providerServices().items.filter((item) => item.enabled && !this.isNativeProvider(item.providerId));
+		const results = await Promise.all(services.map(async (item) => {
+			const provider = this.providers.get(item.providerId);
+			if (provider?.discover === void 0) return void 0;
+			const label = this.providerCatalog.descriptor(item.providerId).label;
+			const timeout = AbortSignal.timeout(providerTimeoutMs);
+			const bounded = signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+			try {
+				const connection = this.memorySpaces.resolveProviderService(item.providerId, {});
+				const discovered = await untilAborted(provider.discover(connection, bounded), bounded);
+				signal?.throwIfAborted();
+				const mounted = this.memorySpaces.mountDiscovered(item.providerId, connection, discovered);
+				return {
+					providerId: item.providerId,
+					label,
+					found: discovered.length,
+					added: mounted.added.map((body) => ({
+						id: body.id,
+						name: body.name
+					})),
+					disconnected: mounted.disconnected
+				};
+			} catch (error) {
+				signal?.throwIfAborted();
+				const failure = {
+					providerId: item.providerId,
+					label,
+					found: 0,
+					added: [],
+					disconnected: 0
+				};
+				if (timeout.aborted) {
+					const limit = providerTimeoutMs < 1e3 ? `${providerTimeoutMs} ms` : `${Math.round(providerTimeoutMs / 1e3)} seconds`;
+					return {
+						...failure,
+						timedOut: true,
+						error: `did not answer within ${limit}`
+					};
+				}
+				return {
+					...failure,
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
+		}));
+		return {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			trigger,
+			results: results.filter((result) => result !== void 0)
+		};
+	}
 	updateSpace(id, request) {
 		this.assertWritable();
 		return this.memorySpaces.update(id, request);
@@ -2707,129 +3339,6 @@ var MemorySpacesService = class {
 	}
 };
 //#endregion
-//#region src/runner.ts
-var MnemonCliError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "MnemonCliError";
-	}
-};
-const EMBEDDING_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
-	"MNEMON_EMBED_ENDPOINT",
-	"MNEMON_EMBED_MODEL",
-	"MNEMON_EMBED_API_KEY",
-	"MNEMON_EMBED_PROTOCOL"
-]);
-/**
-* Explain a CLI call that produced no result. Only a failed launch means the
-* executable is missing or unusable, so only that case carries the install
-* hint; a timeout, a cancellation or an oversized output names its own cause.
-*/
-function processFailureMessage(error, args) {
-	const detail = error instanceof Error ? error.message : String(error);
-	const reason = error instanceof ProcessError ? error.reason : "launch";
-	const command = args.find((arg) => !arg.startsWith("-"));
-	if (reason === "output-limit") return `mnemon ${command ?? "command"} stopped: ${detail.replace(/^mnemon /u, "")}`;
-	if (reason === "timeout" && command !== void 0) return detail.replace(/^mnemon /u, `mnemon ${command} `);
-	if (reason !== "launch") return detail;
-	return `${detail}. ${process.platform === "win32" ? "Install the official Mnemon Windows release, ensure mnemon.exe is on PATH or under %LOCALAPPDATA%\\Programs\\mnemon, or set MNEMON_CLI_PATH or mnemon.cliPath to its absolute path." : "Install Mnemon and ensure \"mnemon\" is on PATH, or set MNEMON_CLI_PATH or mnemon.cliPath."}`;
-}
-/** Preserve the Host environment while making saved embedding overrides authoritative. */
-function processEnvironment(config) {
-	if (!config.embedding.enabled) return void 0;
-	return {
-		...Object.fromEntries(Object.entries(process.env).filter(([key]) => !EMBEDDING_ENVIRONMENT_KEYS.has(key.toUpperCase()))),
-		MNEMON_EMBED_ENDPOINT: config.embedding.endpoint,
-		MNEMON_EMBED_MODEL: config.embedding.model,
-		MNEMON_EMBED_API_KEY: config.embedding.apiKey,
-		...config.embedding.protocol === "auto" ? {} : { MNEMON_EMBED_PROTOCOL: config.embedding.protocol }
-	};
-}
-function createRunner(config, processRunner = runProcess) {
-	const currentCommand = () => findMnemonCommand(config) ?? config.cliPath ?? "mnemon";
-	const globalArgs = (store) => {
-		const args = ["--data-dir", effectiveDataDir()];
-		if (store !== void 0) args.push("--store", store);
-		else if (config.store !== void 0) args.push("--store", config.store);
-		return args;
-	};
-	const effectiveDataDir = () => config.dataDir;
-	const persistedStore = () => {
-		const active = join(effectiveDataDir(), "active");
-		if (existsSync(active)) try {
-			const value = readFileSync(active, "utf8").trim();
-			if (/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value)) return value;
-		} catch {}
-		return "default";
-	};
-	const launch = async (args, options = {}) => {
-		if (options.signal?.aborted === true) throw new MnemonCliError(`mnemon command aborted: ${String(options.signal.reason ?? "cancelled")}`);
-		const argv = options.globalFlags === false ? [...args] : [...globalArgs(options.store), ...args];
-		const environment = processEnvironment(config);
-		const processOptions = {
-			timeoutMs: config.timeoutMs,
-			...environment === void 0 ? {} : { env: environment },
-			...options.signal === void 0 ? {} : { signal: options.signal },
-			...options.maxOutputBytes === void 0 ? {} : { maxOutputBytes: options.maxOutputBytes }
-		};
-		let result;
-		try {
-			const invocation = resolveMnemonInvocation(currentCommand(), argv, environment);
-			result = await processRunner(invocation.command, invocation.args, {
-				...processOptions,
-				...invocation.env === void 0 ? {} : { env: invocation.env }
-			});
-		} catch (error) {
-			throw new MnemonCliError(processFailureMessage(error, args));
-		}
-		if (result.exitCode !== 0) {
-			const detail = result.stderr.trim() || result.stdout.trim() || "no output";
-			throw new MnemonCliError(`mnemon ${args.join(" ")} exited ${String(result.exitCode)}: ${detail}`);
-		}
-		return result.stdout;
-	};
-	const execute = (args, options = {}) => {
-		return withMemoryStorageLock(effectiveDataDir(), () => launch(args, options));
-	};
-	return {
-		get command() {
-			return currentCommand();
-		},
-		get commandFound() {
-			const found = findMnemonCommand(config);
-			return found !== void 0 && isMnemonExecutable(found);
-		},
-		async runJson(args, options) {
-			const stdout = await execute(args, options);
-			try {
-				return JSON.parse(stdout);
-			} catch {
-				throw new MnemonCliError(`mnemon ${args.join(" ")} returned invalid JSON`);
-			}
-		},
-		runText: execute,
-		runTextBatch(commands) {
-			return withMemoryStorageLock(effectiveDataDir(), async () => {
-				const outputs = [];
-				for (const command of commands) outputs.push(await launch(command.args, command.options));
-				return outputs;
-			});
-		},
-		effectiveDataDir() {
-			return effectiveDataDir();
-		},
-		persistedStore() {
-			return persistedStore();
-		},
-		effectiveStore() {
-			if (config.store !== void 0) return config.store;
-			const fromEnvironment = process.env.MNEMON_STORE?.trim();
-			if (fromEnvironment !== void 0 && fromEnvironment !== "") return fromEnvironment;
-			return persistedStore();
-		}
-	};
-}
-//#endregion
 //#region src/config.ts
 const MemorySpacesConfig = z.object({
 	dataDir: z.string(),
@@ -3073,6 +3582,28 @@ function placementDecision(value) {
 		...memoryInputText(input.subagentProvider, "placement decision subagentProvider", 500, false) === void 0 ? {} : { subagentProvider: memoryInputText(input.subagentProvider, "placement decision subagentProvider", 500, false) }
 	};
 }
+/**
+* Why this turn's View cannot forget from a Memory Space it does not read (#390). The View is
+* pinned for the turn, so switching a space on reaches a forget from the next turn only, and
+* whether a space is on stays the user's choice.
+*/
+function outsideView(service, memoryBodyId) {
+	const catalog = service.spaceDirectory();
+	const body = catalog.items.find((candidate) => candidate.id === memoryBodyId);
+	if (body === void 0) return `Memory Space ${JSON.stringify(memoryBodyId)} does not exist`;
+	const space = `Memory Space ${JSON.stringify(memoryBodyId)} (${body.name})`;
+	if (!body.active) return `${space} is switched off, so this turn's View does not read it and cannot forget from it. Whether it is on is the user's choice, on the Memory Spaces page; once it is on, a forget there works from the next turn`;
+	if (body.providerEnabled === false) return `${space} uses ${body.provider.label}, which is turned off on the dsh-mnemon page under Plugins`;
+	const provider = catalog.providers.find((candidate) => candidate.id === body.provider.id);
+	if (provider?.serviceConfigured === false) return `${space} uses ${body.provider.label}, which is not available here${(provider.typeId ?? provider.id) === "mnemon-native" ? ": the Mnemon CLI is not installed" : ""}`;
+	return `${space} was switched on after this turn began, so this turn's View does not read it yet; a forget there works from the next turn`;
+}
+/** The switched-off spaces a forget cannot reach this turn, named only when there are some (#390). */
+function switchedOffSpaces(service) {
+	const off = service.spaceDirectory().items.filter((body) => !body.active);
+	if (off.length === 0) return "";
+	return `. Switched-off spaces (${off.slice(0, 5).map((body) => JSON.stringify(body.name)).join(", ")}${off.length > 5 ? ` and ${off.length - 5} more` : ""}) are outside this View; one the user switches on is read from the next turn`;
+}
 function managementResult(service, value) {
 	return {
 		revision: service.memoryRevision(),
@@ -3129,6 +3660,7 @@ async function manageMemorySpaces(service, request) {
 	}
 	if (!request.confirmed) throw new Error("Memory Spaces management mutation requires explicit confirmation");
 	switch (request.operation) {
+		case "embedding-fill": return managementResult(service, await service.embedMissing(memoryInputText(input.memoryBodyId, "memoryBodyId", 300), request.signal));
 		case "provider-service-update": {
 			const providerId = memoryInputText(input.providerId, "providerId", 128);
 			await service.updateProviderService(providerId, scalarRecord(input.settings, "settings") ?? {}, memoryInputStringArray(input.clearSecrets, "clearSecrets", 100) ?? [], input.enabled === void 0 ? true : input.enabled === true, request.signal);
@@ -3180,6 +3712,7 @@ async function manageMemorySpaces(service, request) {
 		case "reload":
 			service.memorySpaces.reload();
 			return managementResult(service, { reloaded: true });
+		case "provider-rediscover": return managementResult(service, await service.rediscoverProviders(input.trigger === "startup" ? "startup" : "manual", request.signal));
 		case "body-delete": return managementResult(service, await service.deleteSpace(memoryInputText(input.memoryBodyId, "memoryBodyId", 300), request.signal));
 		default: throw new Error(`unsupported Memory Spaces management mutation operation: ${request.operation}`);
 	}
@@ -3678,8 +4211,10 @@ function createMemorySpacesSource(providerSnapshot, config = {}) {
 						result = await service.link(sourceId, targetId, edge, weight, memoryInputText(input.reason, "reason", 1e3, false), request.signal, bodyId);
 					} else if (request.offer.sourceActionId === "forget") {
 						const id = memoryInputText(input.id, "id", 2e3);
+						const named = memoryInputText(input.memoryBodyId, "memoryBodyId", 300, false);
+						if (named !== void 0 && !allowedBodies.includes(named)) throw new Error(outsideView(service, named));
 						bodyId = await admittedOwner(id);
-						if (bodyId === void 0 || !allowedBodies.includes(bodyId)) throw new Error("forget requires evidence already admitted by this View, or an id found in one Memory Space it can read; name the space (memoryBodyId) when several hold it");
+						if (bodyId === void 0 || !allowedBodies.includes(bodyId)) throw new Error(`forget requires evidence already admitted by this View, or an id found in one Memory Space it can read; name the space (memoryBodyId) when several hold it${switchedOffSpaces(service)}`);
 						result = await service.forget(id, request.signal, bodyId);
 					} else throw new Error(`unsupported Memory Spaces action: ${request.offer.sourceActionId}`);
 					return createMemoryMutationReceipt(request.view.id, request.offer.id, context.sourceInstanceKey, service.memoryRevision(), {