dsh-mnemon-source-memory-spaces 0.5.17 → 0.5.19

package/lib/contracts.d.ts

@@ -334,6 +334,35 @@ interface MemorySpaceCatalog {
   generatedAt: string;
   /** Present only when body-directory receives a supported writeScope request. Older Sources omit it. */
   writeScope?: MemorySpaceWriteScope;
+  /** Provider namespaces asked for again in this process: whether a pass is running, and the last one. Older Sources omit it. */
+  rediscovery?: {
+    running: boolean;
+    last?: MemorySpaceRediscovery;
+  };
+}
+/** What one Provider answered when its namespaces were asked for again. */
+interface MemorySpaceRediscoveryResult {
+  providerId: MemoryProviderId;
+  label: string;
+  /** Namespaces the Provider reported. */
+  found: number;
+  /** Spaces mounted for namespaces this directory had never held. They start inactive. */
+  added: Array<{
+    id: string;
+    name: string;
+  }>;
+  /** Reported namespaces a person disconnected here; they stay disconnected. */
+  disconnected: number;
+  /** Why the Provider could not be asked, as it said. Its spaces stay as they were. */
+  error?: string;
+  /** The Provider said nothing within the time it was given. */
+  timedOut?: boolean;
+}
+/** One pass over every enabled Provider service, when the Host starts or from the Memory Spaces page. */
+interface MemorySpaceRediscovery {
+  at: string;
+  trigger: 'startup' | 'manual';
+  results: MemorySpaceRediscoveryResult[];
 }
 interface MemoryGraphNode extends Insight {
   color: string;
@@ -574,4 +603,4 @@ type MemoryBodyView = MemorySpaceView;
 /** @deprecated Use OpenVikingSpaceConnection. The wire shape is unchanged. */
 type OpenVikingBodyConnection = OpenVikingSpaceConnection;
 //#endregion
-export { AutomaticMemoryPlacementRequest, CATEGORIES, Category, CreateMemoryBodyRequest, CreateMemorySpaceRequest, DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, EDGE_TYPES, EMBEDDING_PROTOCOL_AUTO, EMBEDDING_PROTOCOL_OLLAMA, EMBEDDING_PROTOCOL_OPENAI, EdgeType, EntityMemoriesView, EntityRelatedView, EntityView, INTENTS, Insight, Intent, type JsonValue, LlmMemoryPlacementSelection, MNEMON_EMBEDDING_PROTOCOLS, MemoryBody, MemoryBodyCatalog, MemoryBodyMetadataMaintenanceResult, MemoryBodyMetadataSample, MemoryBodyMetadataUpdate, MemoryBodyProvider, MemoryBodyStats, MemoryBodyView, MemoryGraphEdge, MemoryGraphNode, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryPersistenceStrategy, MemoryPlacementCandidate, MemoryPlacementCapability, MemoryPlacementDecision, MemoryPlacementPreference, MemoryPlacementRules, MemoryProviderCapabilities, MemoryProviderConfigField, MemoryProviderConfigOption, MemoryProviderConnection, MemoryProviderConnectionValue, MemoryProviderDescriptor, MemoryProviderIcon, MemoryProviderId, MemoryProviderRuntimeStatus, MemoryProviderServiceCatalog, MemoryProviderServiceView, MemoryReadMode, MemoryReadSource, MemoryReadStatus, MemorySpace, MemorySpaceCatalog, MemorySpaceMetadataMaintenanceResult, MemorySpaceMetadataSample, MemorySpaceMetadataUpdate, MemorySpaceProvider, MemorySpaceStats, MemorySpaceView, MemorySpaceWriteScope, MemorySpaceWriteScopeRequest, MemorySpacesStatus, MnemonEmbeddingConfig, MnemonEmbeddingProtocol, MnemonEmbeddingStatus, OpenVikingBodyConnection, OpenVikingSpaceConnection, PreparedMemoryPlacement, RecallQualityConfig, RecallQualityStats, RecallRelevanceTier, RememberRequest, ResolvedMemoryPersistenceStrategy, ResolvedMnemonEmbeddingConfig, ResolvedRecallQualityConfig, SOURCES, SearchRequest, Source, UpdateMemoryBodyRequest, UpdateMemoryProviderServiceRequest, UpdateMemorySpaceRequest, normalizeEntityKey };
+export { AutomaticMemoryPlacementRequest, CATEGORIES, Category, CreateMemoryBodyRequest, CreateMemorySpaceRequest, DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, EDGE_TYPES, EMBEDDING_PROTOCOL_AUTO, EMBEDDING_PROTOCOL_OLLAMA, EMBEDDING_PROTOCOL_OPENAI, EdgeType, EntityMemoriesView, EntityRelatedView, EntityView, INTENTS, Insight, Intent, type JsonValue, LlmMemoryPlacementSelection, MNEMON_EMBEDDING_PROTOCOLS, MemoryBody, MemoryBodyCatalog, MemoryBodyMetadataMaintenanceResult, MemoryBodyMetadataSample, MemoryBodyMetadataUpdate, MemoryBodyProvider, MemoryBodyStats, MemoryBodyView, MemoryGraphEdge, MemoryGraphNode, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryPersistenceStrategy, MemoryPlacementCandidate, MemoryPlacementCapability, MemoryPlacementDecision, MemoryPlacementPreference, MemoryPlacementRules, MemoryProviderCapabilities, MemoryProviderConfigField, MemoryProviderConfigOption, MemoryProviderConnection, MemoryProviderConnectionValue, MemoryProviderDescriptor, MemoryProviderIcon, MemoryProviderId, MemoryProviderRuntimeStatus, MemoryProviderServiceCatalog, MemoryProviderServiceView, MemoryReadMode, MemoryReadSource, MemoryReadStatus, MemorySpace, MemorySpaceCatalog, MemorySpaceMetadataMaintenanceResult, MemorySpaceMetadataSample, MemorySpaceMetadataUpdate, MemorySpaceProvider, MemorySpaceRediscovery, MemorySpaceRediscoveryResult, MemorySpaceStats, MemorySpaceView, MemorySpaceWriteScope, MemorySpaceWriteScopeRequest, MemorySpacesStatus, MnemonEmbeddingConfig, MnemonEmbeddingProtocol, MnemonEmbeddingStatus, OpenVikingBodyConnection, OpenVikingSpaceConnection, PreparedMemoryPlacement, RecallQualityConfig, RecallQualityStats, RecallRelevanceTier, RememberRequest, ResolvedMemoryPersistenceStrategy, ResolvedMnemonEmbeddingConfig, ResolvedRecallQualityConfig, SOURCES, SearchRequest, Source, UpdateMemoryBodyRequest, UpdateMemoryProviderServiceRequest, UpdateMemorySpaceRequest, normalizeEntityKey };

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { AutomaticMemoryPlacementRequest, CATEGORIES, Category, CreateMemoryBodyRequest, CreateMemorySpaceRequest, DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, EDGE_TYPES, EMBEDDING_PROTOCOL_AUTO, EMBEDDING_PROTOCOL_OLLAMA, EMBEDDING_PROTOCOL_OPENAI, EdgeType, EntityMemoriesView, EntityRelatedView, EntityView, INTENTS, Insight, Intent, JsonValue, LlmMemoryPlacementSelection, MNEMON_EMBEDDING_PROTOCOLS, MemoryBody, MemoryBodyCatalog, MemoryBodyMetadataMaintenanceResult, MemoryBodyMetadataSample, MemoryBodyMetadataUpdate, MemoryBodyProvider, MemoryBodyStats, MemoryBodyView, MemoryGraphEdge, MemoryGraphNode, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryPersistenceStrategy, MemoryPlacementCandidate, MemoryPlacementCapability, MemoryPlacementDecision, MemoryPlacementPreference, MemoryPlacementRules, MemoryProviderCapabilities, MemoryProviderConfigField, MemoryProviderConfigOption, MemoryProviderConnection, MemoryProviderConnectionValue, MemoryProviderDescriptor, MemoryProviderIcon, MemoryProviderId, MemoryProviderRuntimeStatus, MemoryProviderServiceCatalog, MemoryProviderServiceView, MemoryReadMode, MemoryReadSource, MemoryReadStatus, MemorySpace, MemorySpaceCatalog, MemorySpaceMetadataMaintenanceResult, MemorySpaceMetadataSample, MemorySpaceMetadataUpdate, MemorySpaceProvider, MemorySpaceStats, MemorySpaceView, MemorySpaceWriteScope, MemorySpaceWriteScopeRequest, MemorySpacesStatus, MnemonEmbeddingConfig, MnemonEmbeddingProtocol, MnemonEmbeddingStatus, OpenVikingBodyConnection, OpenVikingSpaceConnection, PreparedMemoryPlacement, RecallQualityConfig, RecallQualityStats, RecallRelevanceTier, RememberRequest, ResolvedMemoryPersistenceStrategy, ResolvedMnemonEmbeddingConfig, ResolvedRecallQualityConfig, SOURCES, SearchRequest, Source, UpdateMemoryBodyRequest, UpdateMemoryProviderServiceRequest, UpdateMemorySpaceRequest, normalizeEntityKey } from "./contracts.js";
+import { AutomaticMemoryPlacementRequest, CATEGORIES, Category, CreateMemoryBodyRequest, CreateMemorySpaceRequest, DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, EDGE_TYPES, EMBEDDING_PROTOCOL_AUTO, EMBEDDING_PROTOCOL_OLLAMA, EMBEDDING_PROTOCOL_OPENAI, EdgeType, EntityMemoriesView, EntityRelatedView, EntityView, INTENTS, Insight, Intent, JsonValue, LlmMemoryPlacementSelection, MNEMON_EMBEDDING_PROTOCOLS, MemoryBody, MemoryBodyCatalog, MemoryBodyMetadataMaintenanceResult, MemoryBodyMetadataSample, MemoryBodyMetadataUpdate, MemoryBodyProvider, MemoryBodyStats, MemoryBodyView, MemoryGraphEdge, MemoryGraphNode, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryPersistenceStrategy, MemoryPlacementCandidate, MemoryPlacementCapability, MemoryPlacementDecision, MemoryPlacementPreference, MemoryPlacementRules, MemoryProviderCapabilities, MemoryProviderConfigField, MemoryProviderConfigOption, MemoryProviderConnection, MemoryProviderConnectionValue, MemoryProviderDescriptor, MemoryProviderIcon, MemoryProviderId, MemoryProviderRuntimeStatus, MemoryProviderServiceCatalog, MemoryProviderServiceView, MemoryReadMode, MemoryReadSource, MemoryReadStatus, MemorySpace, MemorySpaceCatalog, MemorySpaceMetadataMaintenanceResult, MemorySpaceMetadataSample, MemorySpaceMetadataUpdate, MemorySpaceProvider, MemorySpaceRediscovery, MemorySpaceRediscoveryResult, MemorySpaceStats, MemorySpaceView, MemorySpaceWriteScope, MemorySpaceWriteScopeRequest, MemorySpacesStatus, MnemonEmbeddingConfig, MnemonEmbeddingProtocol, MnemonEmbeddingStatus, OpenVikingBodyConnection, OpenVikingSpaceConnection, PreparedMemoryPlacement, RecallQualityConfig, RecallQualityStats, RecallRelevanceTier, RememberRequest, ResolvedMemoryPersistenceStrategy, ResolvedMnemonEmbeddingConfig, ResolvedRecallQualityConfig, SOURCES, SearchRequest, Source, UpdateMemoryBodyRequest, UpdateMemoryProviderServiceRequest, UpdateMemorySpaceRequest, normalizeEntityKey } from "./contracts.js";
 import { i as MemorySpaceProviderEntry } from "./definitions-CtjNSwBS.js";
 import z from "@deepseek-ai/schemastery";
 import { Context } from "@deepseek-ai/cordis";
@@ -59,4 +59,4 @@ declare function resolveMemorySpaceProviderEntries(ctx: Context, declarations: r
 declare function installMemorySpaces(ctx: Context, entries: readonly MemorySpaceProviderEntry[], options?: InstallMemorySpacesOptions): Promise<void>;
 declare function apply(ctx: Context, config?: Config): Promise<void>;
 //#endregion
-export { type AutomaticMemoryPlacementRequest, type CATEGORIES, type Category, Config, type CreateMemoryBodyRequest, type CreateMemorySpaceRequest, type DEFAULT_EMBEDDING_ENDPOINT, type DEFAULT_EMBEDDING_MODEL, type DEFAULT_EMBEDDING_PROTOCOL, type EDGE_TYPES, type EMBEDDING_PROTOCOL_AUTO, type EMBEDDING_PROTOCOL_OLLAMA, type EMBEDDING_PROTOCOL_OPENAI, type EdgeType, type EntityMemoriesView, type EntityRelatedView, type EntityView, type INTENTS, type Insight, InstallMemorySpacesOptions, type Intent, type JsonValue, type LlmMemoryPlacementSelection, type MNEMON_EMBEDDING_PROTOCOLS, type MemoryBody, type MemoryBodyCatalog, type MemoryBodyMetadataMaintenanceResult, type MemoryBodyMetadataSample, type MemoryBodyMetadataUpdate, type MemoryBodyProvider, type MemoryBodyStats, type MemoryBodyView, type MemoryGraphEdge, type MemoryGraphNode, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type MemoryPersistenceStrategy, type MemoryPlacementCandidate, type MemoryPlacementCapability, type MemoryPlacementDecision, type MemoryPlacementPreference, type MemoryPlacementRules, type MemoryProviderCapabilities, type MemoryProviderConfigField, type MemoryProviderConfigOption, type MemoryProviderConnection, type MemoryProviderConnectionValue, type MemoryProviderDescriptor, type MemoryProviderIcon, type MemoryProviderId, type MemoryProviderRuntimeStatus, type MemoryProviderServiceCatalog, type MemoryProviderServiceView, type MemoryReadMode, type MemoryReadSource, type MemoryReadStatus, type MemorySpace, type MemorySpaceCatalog, type MemorySpaceMetadataMaintenanceResult, type MemorySpaceMetadataSample, type MemorySpaceMetadataUpdate, type MemorySpaceProvider, MemorySpaceProviderDeclaration, MemorySpaceProviderDeclarationSchema, type MemorySpaceStats, type MemorySpaceView, type MemorySpaceWriteScope, type MemorySpaceWriteScopeRequest, type MemorySpacesStatus, type MnemonEmbeddingConfig, type MnemonEmbeddingProtocol, type MnemonEmbeddingStatus, type OpenVikingBodyConnection, type OpenVikingSpaceConnection, type PreparedMemoryPlacement, type RecallQualityConfig, type RecallQualityStats, type RecallRelevanceTier, type RememberRequest, type ResolvedMemoryPersistenceStrategy, type ResolvedMnemonEmbeddingConfig, type ResolvedRecallQualityConfig, type SOURCES, type SearchRequest, type Source, type UpdateMemoryBodyRequest, type UpdateMemoryProviderServiceRequest, type UpdateMemorySpaceRequest, apply, inject, installMemorySpaces, memoryPlugin, name, type normalizeEntityKey, resolveEmbedding, resolveMemorySpaceProviderEntries, resolvePersistenceStrategy, resolveRecallQuality };
+export { type AutomaticMemoryPlacementRequest, type CATEGORIES, type Category, Config, type CreateMemoryBodyRequest, type CreateMemorySpaceRequest, type DEFAULT_EMBEDDING_ENDPOINT, type DEFAULT_EMBEDDING_MODEL, type DEFAULT_EMBEDDING_PROTOCOL, type EDGE_TYPES, type EMBEDDING_PROTOCOL_AUTO, type EMBEDDING_PROTOCOL_OLLAMA, type EMBEDDING_PROTOCOL_OPENAI, type EdgeType, type EntityMemoriesView, type EntityRelatedView, type EntityView, type INTENTS, type Insight, InstallMemorySpacesOptions, type Intent, type JsonValue, type LlmMemoryPlacementSelection, type MNEMON_EMBEDDING_PROTOCOLS, type MemoryBody, type MemoryBodyCatalog, type MemoryBodyMetadataMaintenanceResult, type MemoryBodyMetadataSample, type MemoryBodyMetadataUpdate, type MemoryBodyProvider, type MemoryBodyStats, type MemoryBodyView, type MemoryGraphEdge, type MemoryGraphNode, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type MemoryPersistenceStrategy, type MemoryPlacementCandidate, type MemoryPlacementCapability, type MemoryPlacementDecision, type MemoryPlacementPreference, type MemoryPlacementRules, type MemoryProviderCapabilities, type MemoryProviderConfigField, type MemoryProviderConfigOption, type MemoryProviderConnection, type MemoryProviderConnectionValue, type MemoryProviderDescriptor, type MemoryProviderIcon, type MemoryProviderId, type MemoryProviderRuntimeStatus, type MemoryProviderServiceCatalog, type MemoryProviderServiceView, type MemoryReadMode, type MemoryReadSource, type MemoryReadStatus, type MemorySpace, type MemorySpaceCatalog, type MemorySpaceMetadataMaintenanceResult, type MemorySpaceMetadataSample, type MemorySpaceMetadataUpdate, type MemorySpaceProvider, MemorySpaceProviderDeclaration, MemorySpaceProviderDeclarationSchema, type MemorySpaceRediscovery, type MemorySpaceRediscoveryResult, type MemorySpaceStats, type MemorySpaceView, type MemorySpaceWriteScope, type MemorySpaceWriteScopeRequest, type MemorySpacesStatus, type MnemonEmbeddingConfig, type MnemonEmbeddingProtocol, type MnemonEmbeddingStatus, type OpenVikingBodyConnection, type OpenVikingSpaceConnection, type PreparedMemoryPlacement, type RecallQualityConfig, type RecallQualityStats, type RecallRelevanceTier, type RememberRequest, type ResolvedMemoryPersistenceStrategy, type ResolvedMnemonEmbeddingConfig, type ResolvedRecallQualityConfig, type SOURCES, type SearchRequest, type Source, type UpdateMemoryBodyRequest, type UpdateMemoryProviderServiceRequest, type UpdateMemorySpaceRequest, apply, inject, installMemorySpaces, memoryPlugin, name, type normalizeEntityKey, resolveEmbedding, resolveMemorySpaceProviderEntries, resolvePersistenceStrategy, resolveRecallQuality };

package/lib/index.js

@@ -103,9 +103,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 +247,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 +259,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 +286,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 +441,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 +770,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 +837,7 @@ var MemorySpaceRegistry = class MemorySpaceRegistry {
 			this.spaces = [];
 			this.services = {};
 			this.serviceEnabled = {};
+			this.disconnected = {};
 			this.loadAndReconcile();
 			this.state.diskRevision = this.diskRevision();
 		} finally {
@@ -629,7 +846,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 +969,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 +1077,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`, {
@@ -1300,6 +1544,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)");
@@ -1624,7 +1887,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. */
@@ -2509,6 +2780,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);
@@ -3180,6 +3534,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}`);
 	}
@@ -3800,7 +4155,17 @@ async function installMemorySpaces(ctx, entries, options = {}) {
 		throw error;
 	}
 }
+/**
+* dshmarket's client-only mount of a Memory Spaces package installed on its own
+* in a profile, `include:dsh-market:mkt-client-<package>`: it is meant to run no
+* host code, and the Starter's own Entry composes the Source with its Providers (#359).
+*/
+function isMarketClientShim(ctx) {
+	const loader = ctx.get("loader", false);
+	return /(?:^|:)mkt-client-[^:]*$/u.test(loader?.locate(ctx.fiber)?.trim() ?? "");
+}
 async function apply(ctx, config = { providers: [] }) {
+	if (isMarketClientShim(ctx)) return;
 	const { providers, ...sourceConfig } = config;
 	await installMemorySpaces(ctx, await resolveMemorySpaceProviderEntries(ctx, providers), { config: sourceConfig });
 }

package/lib/types/client/api.d.ts

@@ -1,4 +1,4 @@
-import type { CreateMemorySpaceRequest, EntityMemoriesView, EntityRelatedView, EntityView, Insight, MemorySpace, MemorySpaceView, MemorySpaceMetadataMaintenanceResult, MemorySpaceCatalog, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryReadSource, RememberRequest, SearchRequest, UpdateMemorySpaceRequest } from '../contracts.ts';
+import type { CreateMemorySpaceRequest, EntityMemoriesView, EntityRelatedView, EntityView, Insight, MemorySpace, MemorySpaceView, MemorySpaceMetadataMaintenanceResult, MemorySpaceCatalog, MemorySpaceRediscovery, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryReadSource, RememberRequest, SearchRequest, UpdateMemorySpaceRequest } from '../contracts.ts';
 /**
  * Source-owned structural page API; the default bundle may supply agent-assisted callbacks.
  * body/bodies method and wire-field spellings remain compatible with existing
@@ -33,6 +33,8 @@ export interface MemorySpacesPageClient {
     reconnectBody(memoryBodyId: string): Promise<MemorySpaceView>;
     maintainBodyMetadata(memoryBodyIds: string[]): Promise<MemorySpaceMetadataMaintenanceResult>;
     deleteBody(memoryBodyId: string): Promise<MemorySpace>;
+    /** Ask every enabled Provider again for namespaces it gained; optional for page clients written against an older Source. */
+    rediscoverBodies?(): Promise<MemorySpaceRediscovery>;
 }
 export interface SearchResponse {
     results: Insight[];

package/lib/types/contracts.d.ts

@@ -340,6 +340,35 @@ export interface MemorySpaceCatalog {
     generatedAt: string;
     /** Present only when body-directory receives a supported writeScope request. Older Sources omit it. */
     writeScope?: MemorySpaceWriteScope;
+    /** Provider namespaces asked for again in this process: whether a pass is running, and the last one. Older Sources omit it. */
+    rediscovery?: {
+        running: boolean;
+        last?: MemorySpaceRediscovery;
+    };
+}
+/** What one Provider answered when its namespaces were asked for again. */
+export interface MemorySpaceRediscoveryResult {
+    providerId: MemoryProviderId;
+    label: string;
+    /** Namespaces the Provider reported. */
+    found: number;
+    /** Spaces mounted for namespaces this directory had never held. They start inactive. */
+    added: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Reported namespaces a person disconnected here; they stay disconnected. */
+    disconnected: number;
+    /** Why the Provider could not be asked, as it said. Its spaces stay as they were. */
+    error?: string;
+    /** The Provider said nothing within the time it was given. */
+    timedOut?: boolean;
+}
+/** One pass over every enabled Provider service, when the Host starts or from the Memory Spaces page. */
+export interface MemorySpaceRediscovery {
+    at: string;
+    trigger: 'startup' | 'manual';
+    results: MemorySpaceRediscoveryResult[];
 }
 export interface MemoryGraphNode extends Insight {
     color: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon-source-memory-spaces",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "description": "Memory Spaces Source and its private Provider SDK.",
   "license": "MIT",
   "type": "module",
@@ -65,14 +65,14 @@
     "@types/node": "^22.0.0",
     "@types/react": "^18.3.0",
     "@types/react-dom": "^18.3.0",
-    "dsh-mnemon": "^0.5.25",
+    "dsh-mnemon": "^0.5.29",
     "dsh-mnemon-provider-byterover": "^0.5.5",
-    "dsh-mnemon-provider-hindsight": "^0.5.5",
+    "dsh-mnemon-provider-hindsight": "^0.5.6",
     "dsh-mnemon-provider-holographic": "^0.5.6",
     "dsh-mnemon-provider-honcho": "^0.5.5",
     "dsh-mnemon-provider-mem0": "^0.5.5",
     "dsh-mnemon-provider-mnemon-native": "^0.5.9",
-    "dsh-mnemon-provider-openviking": "^0.5.7",
+    "dsh-mnemon-provider-openviking": "^0.5.8",
     "dsh-mnemon-provider-retaindb": "^0.5.5",
     "dsh-mnemon-provider-supermemory": "^0.5.5",
     "jsdom": "^26.0.0",