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

package/lib/{process-DIK9NnTg.js → adapter-D-BnWkko.js}

@@ -1,8 +1,5 @@
 import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
-//#region src/providers/adapter.ts
-const NORMALIZED_RELEVANCE_SCORE = Object.freeze({ kind: "normalized-relevance" });
-//#endregion
 //#region src/providers/process.ts
 var ProcessError = class extends Error {
 	reason;
@@ -91,4 +88,7 @@ const runProcess = (command, args, options) => new Promise((resolve, reject) =>
 	else options.signal?.addEventListener("abort", abort, { once: true });
 });
 //#endregion
-export { NORMALIZED_RELEVANCE_SCORE as i, ProcessError as n, runProcess as r, DEFAULT_MAX_OUTPUT_BYTES as t };
+//#region src/providers/adapter.ts
+const NORMALIZED_RELEVANCE_SCORE = Object.freeze({ kind: "normalized-relevance" });
+//#endregion
+export { runProcess as i, DEFAULT_MAX_OUTPUT_BYTES as n, ProcessError as r, NORMALIZED_RELEVANCE_SCORE as t };

package/lib/client.js

@@ -4258,7 +4258,8 @@ window.__ModuleLoader__.load({
 					setOutcome({
 						content: candidate,
 						action: response.action,
-						summary: response.summary
+						summary: response.summary,
+						unembedded: (response.unembedded ?? []).length > 0
 					});
 					props.onMutate();
 				} catch (reason) {
@@ -4288,7 +4289,8 @@ window.__ModuleLoader__.load({
 					setOutcome({
 						content: candidate,
 						action: typeof response.action === "string" ? response.action : "stored",
-						summary: typeof response.summary === "string" ? response.summary : ""
+						summary: typeof response.summary === "string" ? response.summary : "",
+						unembedded: response.embedded === false
 					});
 					props.onMutate();
 				} catch (reason) {
@@ -4330,6 +4332,7 @@ window.__ModuleLoader__.load({
 							action: outcome.action,
 							summary: outcome.summary,
 							error: outcome.error,
+							unembedded: outcome.unembedded,
 							onView: props.onView
 						})
 					]

package/lib/contracts.d.ts

@@ -519,9 +519,38 @@ interface MnemonEmbeddingStatus {
   model: string;
   /** Protocol Mnemon resolved for the embedding endpoint; omitted when the CLI does not report one. */
   protocol?: string;
+  /** Across the spaces in `spaces` that could be counted; 0 when no space has a database. */
   totalInsights: number;
   embedded: number;
   coverage: string;
+  /** Each Mnemon Native space with a database, as `mnemon --store <id> embed --status` counts it (#392). */
+  spaces?: MnemonEmbeddingSpaceStatus[];
+}
+/** One Mnemon Native space's vector coverage. */
+interface MnemonEmbeddingSpaceStatus {
+  memoryBodyId: string;
+  name: string;
+  active: boolean;
+  totalInsights: number;
+  embedded: number;
+  coverage: string;
+  /** Why the space could not be counted; its counts are then 0 and stay out of the total. */
+  error?: string;
+}
+/** What one fill of a Mnemon Native space's missing vectors did (#392). */
+interface MnemonEmbeddingFill {
+  memoryBodyId: string;
+  /** Vectors the fill wrote. */
+  filled: number;
+  /** Memories of the space still without a vector when it stopped. */
+  remaining: number;
+  /** The embedding model Mnemon used. */
+  model: string;
+  /**
+   * Why it stopped while memories remain: its minute ran out (`time`), or a step wrote no vector,
+   * so the embedding service returned none for the memories left (`refused`).
+   */
+  stopped?: 'time' | 'refused';
 }
 /** Domain status only; workbench/lifecycle status belongs to the default adapter. */
 interface MemorySpacesStatus {
@@ -603,4 +632,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, 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 };
+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, MnemonEmbeddingFill, MnemonEmbeddingProtocol, MnemonEmbeddingSpaceStatus, 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, 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 { 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, MnemonEmbeddingFill, MnemonEmbeddingProtocol, MnemonEmbeddingSpaceStatus, 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 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 };
+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 MnemonEmbeddingFill, type MnemonEmbeddingProtocol, type MnemonEmbeddingSpaceStatus, 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

@@ -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,
@@ -1103,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",
@@ -1749,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;
@@ -1973,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) {
@@ -3061,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(),
@@ -3427,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(),
@@ -3483,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);
@@ -4033,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(), {

package/lib/provider-sdk.js

@@ -1,5 +1,5 @@
 import { CATEGORIES, EDGE_TYPES, INTENTS, SOURCES } from "./contracts.js";
-import { i as NORMALIZED_RELEVANCE_SCORE, n as ProcessError, r as runProcess, t as DEFAULT_MAX_OUTPUT_BYTES } from "./process-DIK9NnTg.js";
+import { i as runProcess, n as DEFAULT_MAX_OUTPUT_BYTES, r as ProcessError, t as NORMALIZED_RELEVANCE_SCORE } from "./adapter-D-BnWkko.js";
 import { i as defineMemorySpaceProviderDefinition, r as defineMemorySpaceProvider, t as MEMORY_SPACE_PROVIDER_API_VERSION } from "./definitions-DfmOqJjR.js";
 //#region src/providers/http.ts
 function jsonObject(value) {

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

@@ -26,6 +26,10 @@ export interface MemorySpacesPageClient {
         summary: string;
         action: string;
         memoryBodyIds: string[];
+        unembedded?: Array<{
+            memoryBodyId?: string;
+            id?: string;
+        }>;
     }>;
     forget(id: string, memoryBodyId?: string): Promise<Record<string, unknown>>;
     createBody(request: CreateMemorySpaceRequest): Promise<MemorySpace>;

package/lib/types/contracts.d.ts

@@ -525,9 +525,38 @@ export interface MnemonEmbeddingStatus {
     model: string;
     /** Protocol Mnemon resolved for the embedding endpoint; omitted when the CLI does not report one. */
     protocol?: string;
+    /** Across the spaces in `spaces` that could be counted; 0 when no space has a database. */
     totalInsights: number;
     embedded: number;
     coverage: string;
+    /** Each Mnemon Native space with a database, as `mnemon --store <id> embed --status` counts it (#392). */
+    spaces?: MnemonEmbeddingSpaceStatus[];
+}
+/** One Mnemon Native space's vector coverage. */
+export interface MnemonEmbeddingSpaceStatus {
+    memoryBodyId: string;
+    name: string;
+    active: boolean;
+    totalInsights: number;
+    embedded: number;
+    coverage: string;
+    /** Why the space could not be counted; its counts are then 0 and stay out of the total. */
+    error?: string;
+}
+/** What one fill of a Mnemon Native space's missing vectors did (#392). */
+export interface MnemonEmbeddingFill {
+    memoryBodyId: string;
+    /** Vectors the fill wrote. */
+    filled: number;
+    /** Memories of the space still without a vector when it stopped. */
+    remaining: number;
+    /** The embedding model Mnemon used. */
+    model: string;
+    /**
+     * Why it stopped while memories remain: its minute ran out (`time`), or a step wrote no vector,
+     * so the embedding service returned none for the memories left (`refused`).
+     */
+    stopped?: 'time' | 'refused';
 }
 /** Domain status only; workbench/lifecycle status belongs to the default adapter. */
 export interface MemorySpacesStatus {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon-source-memory-spaces",
-  "version": "0.5.19",
+  "version": "0.5.20",
   "description": "Memory Spaces Source and its private Provider SDK.",
   "license": "MIT",
   "type": "module",
@@ -65,7 +65,7 @@
     "@types/node": "^22.0.0",
     "@types/react": "^18.3.0",
     "@types/react-dom": "^18.3.0",
-    "dsh-mnemon": "^0.5.29",
+    "dsh-mnemon": "^0.5.30",
     "dsh-mnemon-provider-byterover": "^0.5.5",
     "dsh-mnemon-provider-hindsight": "^0.5.6",
     "dsh-mnemon-provider-holographic": "^0.5.6",