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

package/lib/index.js

@@ -1,5 +1,5 @@
 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 } from "./contracts.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 { r as defineMemorySpaceProvider } from "./definitions-DfmOqJjR.js";
@@ -45,8 +45,11 @@ function modelStatus(status) {
 	const unhealthy = active.filter((body) => !body.healthy);
 	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);
+	const notice = status.memoryBodies.length > 0 ? void 0 : providerReady ? "No Memory Space exists yet, so durable memory has nowhere to go and a full MEMORY.md archives to a local file. Create and activate a Memory Space to keep durable memory." : "No Memory Space exists, and none can be created until a memory Provider is ready, so durable memory has nowhere to go and a full MEMORY.md archives to a local file. Install the Mnemon CLI for Mnemon Native, or connect another Provider on the dsh-mnemon page under Plugins, then create and activate a Memory Space.";
 	return {
 		healthy: status.healthy && unhealthy.length === 0,
+		...notice === void 0 ? {} : { notice },
 		...status.error === void 0 ? {} : { error: boundedToolText(status.error, 1e3) },
 		...status.version === void 0 ? {} : { version: boundedToolText(status.version, 120) },
 		commandFound: status.commandFound,
@@ -999,6 +1002,88 @@ function lexicalRequiredMatchCount(tokens) {
 	return Math.max(2, Math.ceil(tokens.length / 4));
 }
 //#endregion
+//#region src/entity-index.ts
+/**
+* The most memories one space's derived index asks list() for. Mnemon Native
+* lists a whole store; a Provider that stops earlier reports what it listed.
+*/
+const ENTITY_INDEX_LIST_LIMIT = 1e5;
+/** The rail lists at most this many entities; the rest stay reachable by name. */
+const ENTITY_RAIL_LIMIT = 5e3;
+function buildSpaceEntityIndex(memories, memoryCount, complete) {
+	const kept = [];
+	const byKey = /* @__PURE__ */ new Map();
+	const spellings = /* @__PURE__ */ new Map();
+	for (const memory of memories) {
+		const seen = /* @__PURE__ */ new Set();
+		let position;
+		for (const raw of memory.entities ?? []) {
+			if (typeof raw !== "string") continue;
+			const key = normalizeEntityKey(raw);
+			if (key === "" || seen.has(key)) continue;
+			seen.add(key);
+			if (position === void 0) {
+				position = kept.length;
+				kept.push(memory);
+			}
+			const positions = byKey.get(key);
+			if (positions === void 0) byKey.set(key, [position]);
+			else positions.push(position);
+			const name = raw.normalize("NFKC").trim();
+			const names = spellings.get(key);
+			if (names === void 0) spellings.set(key, /* @__PURE__ */ new Map([[name, 1]]));
+			else names.set(name, (names.get(name) ?? 0) + 1);
+		}
+	}
+	return {
+		memories: kept,
+		byKey,
+		spellings,
+		memoryCount,
+		complete
+	};
+}
+/** The spelling most memories use; the first one seen wins a tie. */
+function preferredSpelling(names) {
+	let preferred = "";
+	let most = 0;
+	for (const [name, count] of names) if (count > most) {
+		preferred = name;
+		most = count;
+	}
+	return preferred;
+}
+/** Merge per-space indexes into one entity list, most frequent first. */
+function mergeEntityCounts(indexes) {
+	const counts = /* @__PURE__ */ new Map();
+	const spellings = /* @__PURE__ */ new Map();
+	for (const index of indexes) for (const [key, positions] of index.byKey) {
+		counts.set(key, (counts.get(key) ?? 0) + positions.length);
+		let totals = spellings.get(key);
+		if (totals === void 0) spellings.set(key, totals = /* @__PURE__ */ new Map());
+		for (const [name, count] of index.spellings.get(key) ?? []) totals.set(name, (totals.get(name) ?? 0) + count);
+	}
+	const names = /* @__PURE__ */ new Map();
+	for (const [key, totals] of spellings) names.set(key, preferredSpelling(totals));
+	return {
+		items: [...counts].map(([key, count]) => ({
+			entity: names.get(key),
+			count
+		})).sort((left, right) => right.count - left.count || left.entity.localeCompare(right.entity)),
+		names
+	};
+}
+/** Importance first, then the newest; the order Mnemon Native lists a store in. */
+function compareEntityMemories(left, right) {
+	return (right.importance ?? 0) - (left.importance ?? 0) || (right.createdAt ?? "").localeCompare(left.createdAt ?? "") || (left.memoryBodyName ?? "").localeCompare(right.memoryBodyName ?? "") || left.id.localeCompare(right.id);
+}
+/** Every memory across the indexes that carries the entity key. */
+function memoriesWithEntity(indexes, key) {
+	const memories = [];
+	for (const index of indexes) for (const position of index.byKey.get(key) ?? []) memories.push(index.memories[position]);
+	return memories.sort(compareEntityMemories);
+}
+//#endregion
 //#region src/recall-quality/policies.ts
 function expandedLimit(context) {
 	return Math.min(50, Math.max(context.requestedLimit, Math.ceil(context.requestedLimit * context.config.candidateMultiplier)));
@@ -1208,6 +1293,39 @@ function text(value) {
 function number(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+/**
+* How long a selection reuses the Provider health its index was checked with.
+* The rail always checks again; a write through this Source drops both at once.
+*/
+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;
+function entityName(entity) {
+	const name = entity.trim();
+	if (name.length > 200) throw new Error("entity is too long (max 200 characters)");
+	return name;
+}
+function memoryKey(memoryBodyId, id) {
+	return `${memoryBodyId}\u0000${id}`;
+}
+/**
+* What must stay the same for a space's entity index to stay valid: its
+* Provider statistics (Mnemon counts every write in its operation log) and the
+* Source's own record of the space. Without statistics it cannot be checked.
+*/
+function entityIndexFingerprint(body, status) {
+	const stats = status.stats;
+	if (stats === void 0) return void 0;
+	return JSON.stringify([
+		body.provider.id,
+		body.updatedAt,
+		stats.totalInsights,
+		stats.deletedInsights,
+		stats.edgeCount,
+		stats.oplogCount,
+		stats.dbSizeBytes
+	]);
+}
 function readSource(body, mode, status, itemCount, options = {}) {
 	return {
 		memoryBodyId: body.id,
@@ -1377,6 +1495,12 @@ var MemorySpacesService = class {
 	providers;
 	recallQualityPolicy;
 	spacesInFlight;
+	/** One entity index per active entity space, valid while its fingerprint holds. */
+	entityIndexCache = /* @__PURE__ */ new Map();
+	/** settledAt stays undefined while the read runs, which every caller shares. */
+	entityStatusCache = /* @__PURE__ */ new Map();
+	/** The related read each page view is waiting for; a newer selection cancels the older one. */
+	entityRelatedViews = /* @__PURE__ */ new Map();
 	providersDisposed = false;
 	/** The CLI version a full status last read, and the binary it read it from. */
 	cliVersion;
@@ -1512,7 +1636,8 @@ var MemorySpacesService = class {
 		const all = this.memorySpaces.list();
 		const serviceItems = this.memorySpaces.providerServices().items;
 		const enabled = new Set(serviceItems.filter((service) => service.enabled).map((service) => service.providerId));
-		const active = all.filter((body) => body.active && (this.isNativeSpace(body) || enabled.has(body.provider.id))).sort((left, right) => left.id.localeCompare(right.id));
+		const commandFound = this.runner.commandFound;
+		const active = all.filter((body) => body.active && (this.isNativeSpace(body) ? commandFound : enabled.has(body.provider.id))).sort((left, right) => left.id.localeCompare(right.id));
 		const spaces = [...all].sort((left, right) => left.id.localeCompare(right.id)).map((body) => ({
 			id: body.id,
 			name: body.name,
@@ -1527,13 +1652,16 @@ var MemorySpacesService = class {
 			enabled: service.enabled,
 			configured: service.configured
 		})).sort((left, right) => left.providerId.localeCompare(right.providerId));
+		const revision = createHash("sha256").update(JSON.stringify({
+			bodies: spaces,
+			services,
+			...commandFound ? {} : { nativeUnavailable: true }
+		})).digest("hex");
 		return {
 			all,
 			active,
-			revision: createHash("sha256").update(JSON.stringify({
-				bodies: spaces,
-				services
-			})).digest("hex")
+			providerReady: this.memorySpaces.defaultProviderId() !== void 0,
+			revision
 		};
 	}
 	/** Return a usable system snapshot without waiting for any Provider I/O. */
@@ -1688,6 +1816,7 @@ var MemorySpacesService = class {
 		}
 		const provider = this.providerFor(body);
 		provider.invalidateStatus?.(body.id);
+		this.invalidateEntityIndex(body.id);
 		const status = await provider.status(body, signal);
 		return {
 			...body,
@@ -1696,7 +1825,8 @@ var MemorySpacesService = class {
 			...status
 		};
 	}
-	async search(request, signal) {
+	/** exclude: memoryKey()s to leave out before the quality policy selects. */
+	async search(request, signal, options = {}) {
 		const query = required(request.query, "query", 2e3);
 		const limit = memoryInputInteger(request.limit, this.config.defaultRecallLimit, 1, 50);
 		const qualityContext = {
@@ -1719,7 +1849,8 @@ var MemorySpacesService = class {
 			limit: preparedPolicy.candidateLimit,
 			...category === void 0 ? {} : { category },
 			...source === void 0 ? {} : { source },
-			...intent === void 0 ? {} : { intent }
+			...intent === void 0 ? {} : { intent },
+			...request.inspect === true ? { inspect: true } : {}
 		};
 		let batches = await Promise.all(spaces.map(async (body) => {
 			if (!body.provider.capabilities.search) return {
@@ -1755,7 +1886,8 @@ var MemorySpacesService = class {
 			const hints = [];
 			for (const [bodyOrder, { body, result }] of selectedBatches.entries()) {
 				const scoreSemantics = this.providerFor(body).scoreSemantics;
-				candidates.push(...result.results.map((entry, index) => ({
+				const entries = options.exclude === void 0 ? result.results : result.results.filter((entry) => !options.exclude.has(memoryKey(body.id, entry.id)));
+				candidates.push(...entries.map((entry, index) => ({
 					insight: this.annotate(entry, body),
 					memoryBodyId: body.id,
 					providerId: body.provider.id,
@@ -1782,7 +1914,8 @@ var MemorySpacesService = class {
 					const recovered = await this.providerFor(batch.body).search(batch.body, {
 						query: recoveryPlan.query,
 						mode: "keyword",
-						limit: Math.min(limit, preparedPolicy.candidateLimit)
+						limit: Math.min(limit, preparedPolicy.candidateLimit),
+						...request.inspect === true ? { inspect: true } : {}
 					}, signal);
 					const admitted = recovered.results.some((insight) => recoveryMatchCount(insight.content, recoveryPlan) >= recoveryPlan.requiredMatches);
 					const results = mergeRecoveryResults(batch.result.results, recovered.results, recoveryPlan, preparedPolicy.candidateLimit);
@@ -2013,41 +2146,209 @@ var MemorySpacesService = class {
 			sources: batches.map((batch) => batch.source)
 		};
 	}
+	/**
+	* The entities of the active spaces, each counted once per memory that
+	* carries it. With an entity, also the first page of those memories.
+	*/
 	async entities(entity, limit, signal) {
-		const active = (await this.spaces(signal)).items.filter((body) => body.active);
-		const capable = active.filter((body) => body.provider.capabilities.entities);
-		const entityCounts = /* @__PURE__ */ new Map();
-		for (const body of capable) for (const item of body.stats?.topEntities ?? []) entityCounts.set(item.entity, (entityCounts.get(item.entity) ?? 0) + item.count);
-		const items = [...entityCounts].map(([name, count]) => ({
-			entity: name,
-			count
-		})).sort((left, right) => right.count - left.count);
-		const sources = active.map((body) => {
-			if (!body.provider.capabilities.entities) return readSource(body, "unsupported", "unsupported", 0, { hint: "This provider does not expose an entity index." });
-			if (!body.healthy) return readSource(body, "entities", "unavailable", 0, { hint: body.error ?? "Provider unavailable." });
-			const count = body.stats?.topEntities.length ?? 0;
-			return readSource(body, "entities", count === 0 ? "empty" : "ready", count);
-		});
-		const selected = entity?.trim() ?? "";
-		if (selected === "") return {
-			items,
+		const selected = entity === void 0 ? "" : entityName(entity);
+		const read = await this.readEntityIndexes(signal, 0);
+		const { items } = mergeEntityCounts(read.indexes);
+		const view = {
+			items: items.slice(0, ENTITY_RAIL_LIMIT),
 			insights: [],
-			sources
+			sources: read.sources,
+			total: items.length,
+			complete: read.complete
 		};
-		if (selected.length > 200) throw new Error("entity is too long (max 200 characters)");
-		const readableIds = capable.filter((body) => body.healthy).map((body) => body.id);
+		if (selected === "") return view;
+		const page = this.entityPage(read, selected, 0, memoryInputInteger(limit, 20, 1, 50));
 		return {
-			items,
-			selected,
-			insights: readableIds.length === 0 ? [] : (await this.search({
+			...view,
+			selected: page.entity,
+			insights: page.items
+		};
+	}
+	/** One page of the memories that carry an entity, by importance and then recency. */
+	async entityMemories(entity, offset, limit, signal) {
+		const selected = entityName(entity);
+		if (selected === "") throw new Error("entity is required");
+		const read = await this.readEntityIndexes(signal, ENTITY_SELECTION_STATUS_REUSE_MS);
+		return this.entityPage(read, selected, memoryInputInteger(offset, 0, 0, 1e6), memoryInputInteger(limit, 50, 1, 200));
+	}
+	/**
+	* What recall relates to an entity, without the memories that carry it.
+	* Those are left out before the quality policy selects, so they cannot use up
+	* its places and leave the related list empty.
+	*/
+	async entityRelated(entity, limit, signal, view) {
+		const selected = entityName(entity);
+		if (selected === "") throw new Error("entity is required");
+		const superseding = view === void 0 ? void 0 : new AbortController();
+		if (view !== void 0) {
+			this.entityRelatedViews.get(view)?.abort(/* @__PURE__ */ new Error("superseded by a newer entity selection"));
+			this.entityRelatedViews.set(view, superseding);
+		}
+		const combined = superseding === void 0 ? signal : signal === void 0 ? superseding.signal : AbortSignal.any([signal, superseding.signal]);
+		try {
+			const read = await this.readEntityIndexes(combined, ENTITY_SELECTION_STATUS_REUSE_MS);
+			const key = normalizeEntityKey(selected);
+			const carrying = /* @__PURE__ */ new Set();
+			for (const [bodyId, index] of read.byBody) for (const position of index.byKey.get(key) ?? []) carrying.add(memoryKey(bodyId, index.memories[position].id));
+			const display = mergeEntityCounts(read.indexes).names.get(key) ?? selected;
+			const readableIds = read.readable.map((body) => body.id);
+			if (readableIds.length === 0) return {
+				entity: display,
+				items: [],
+				sources: []
+			};
+			const result = await this.search({
 				query: selected,
 				intent: "ENTITY",
 				limit: memoryInputInteger(limit, 20, 1, 50),
-				memoryBodyIds: readableIds
-			}, signal)).results,
-			sources
+				memoryBodyIds: readableIds,
+				inspect: true
+			}, combined, { exclude: carrying });
+			combined?.throwIfAborted();
+			return {
+				entity: display,
+				items: result.results,
+				sources: result.sources
+			};
+		} finally {
+			if (view !== void 0 && this.entityRelatedViews.get(view) === superseding) this.entityRelatedViews.delete(view);
+		}
+	}
+	entityPage(read, selected, offset, limit) {
+		const key = normalizeEntityKey(selected);
+		const memories = memoriesWithEntity(read.indexes, key);
+		return {
+			entity: mergeEntityCounts(read.indexes).names.get(key) ?? selected,
+			total: memories.length,
+			offset,
+			items: memories.slice(offset, offset + limit),
+			complete: read.complete,
+			sources: read.sources
 		};
 	}
+	/**
+	* One entity index per active space that has an entity index, read
+	* concurrently. A space keeps its index while its Provider statistics and
+	* metadata stay the same; a write through this Source drops it.
+	*/
+	async readEntityIndexes(signal, statusMaxAgeMs) {
+		signal?.throwIfAborted();
+		const active = this.memorySpaces.active();
+		const capable = new Set(active.filter((body) => body.provider.capabilities.entities).map((body) => body.id));
+		for (const id of this.entityIndexCache.keys()) if (!capable.has(id)) this.entityIndexCache.delete(id);
+		const reads = await Promise.all(active.map(async (body) => {
+			if (!body.provider.capabilities.entities) return {
+				body,
+				recall: false,
+				source: readSource(body, "unsupported", "unsupported", 0, { hint: "This provider does not expose an entity index." })
+			};
+			const status = await this.entitySpaceStatus(body, statusMaxAgeMs);
+			if (!status.healthy) return {
+				body,
+				recall: false,
+				source: readSource(body, "entities", "unavailable", 0, { hint: status.error ?? "Provider unavailable." })
+			};
+			const recall = body.provider.capabilities.search;
+			if (this.providerFor(body).entityIndex === void 0 && !body.provider.capabilities.browse) return {
+				body,
+				recall,
+				source: readSource(body, "query-only", "query-required", 0, { hint: "This provider can only be queried; its memories appear among related memories." })
+			};
+			try {
+				const index = await this.entityIndexFor(body, status);
+				const options = {
+					memoryCount: index.memoryCount,
+					complete: index.complete,
+					...index.complete ? {} : { hint: "The Provider indexed only part of this space." }
+				};
+				return {
+					body,
+					index,
+					recall,
+					source: readSource(body, "entities", index.byKey.size === 0 ? "empty" : "ready", index.byKey.size, options)
+				};
+			} catch (error) {
+				return {
+					body,
+					recall: false,
+					source: readSource(body, "entities", "unavailable", 0, { hint: error instanceof Error ? error.message : String(error) })
+				};
+			}
+		}));
+		signal?.throwIfAborted();
+		const byBody = /* @__PURE__ */ new Map();
+		for (const read of reads) if (read.index !== void 0) byBody.set(read.body.id, read.index);
+		const indexes = [...byBody.values()];
+		return {
+			byBody,
+			indexes,
+			readable: reads.filter((read) => read.recall).map((read) => read.body),
+			sources: reads.map((read) => read.source),
+			complete: indexes.every((index) => index.complete)
+		};
+	}
+	/** Provider health for the entity reads: a read in flight is shared, a finished one reused for less than maxAgeMs. */
+	entitySpaceStatus(body, maxAgeMs) {
+		const recent = this.entityStatusCache.get(body.id);
+		if (recent !== void 0 && (recent.settledAt === void 0 || Date.now() - recent.settledAt < maxAgeMs)) return recent.status;
+		const entry = {
+			settledAt: void 0,
+			status: Promise.resolve(void 0)
+		};
+		entry.status = this.providerFor(body).status(body).catch((error) => ({
+			healthy: false,
+			error: error instanceof Error ? error.message : String(error)
+		})).then((status) => {
+			entry.settledAt = Date.now();
+			return status;
+		});
+		this.entityStatusCache.set(body.id, entry);
+		return entry.status;
+	}
+	entityIndexFor(body, status) {
+		const fingerprint = entityIndexFingerprint(body, status);
+		const cached = this.entityIndexCache.get(body.id);
+		if (cached !== void 0 && cached.fingerprint === fingerprint) {
+			if (fingerprint !== void 0 || cached.settledAt === void 0 || Date.now() - cached.settledAt < ENTITY_INDEX_UNCHECKED_REUSE_MS) return cached.index;
+		}
+		const entry = {
+			fingerprint,
+			settledAt: void 0,
+			index: Promise.resolve(void 0)
+		};
+		entry.index = this.buildEntityIndex(body).then((index) => {
+			entry.settledAt = Date.now();
+			return index;
+		}, (error) => {
+			if (this.entityIndexCache.get(body.id) === entry) this.entityIndexCache.delete(body.id);
+			throw error;
+		});
+		this.entityIndexCache.set(body.id, entry);
+		return entry.index;
+	}
+	async buildEntityIndex(body) {
+		const provider = this.providerFor(body);
+		if (provider.entityIndex !== void 0) {
+			const owned = await provider.entityIndex(body);
+			return buildSpaceEntityIndex(owned.memories.map((memory) => this.entityMemory(memory, body)), owned.memories.length, owned.complete);
+		}
+		const listed = await provider.list(body, { limit: ENTITY_INDEX_LIST_LIMIT });
+		return buildSpaceEntityIndex(listed.map((memory) => this.entityMemory(memory, body)), listed.length, listed.length < ENTITY_INDEX_LIST_LIMIT);
+	}
+	/** A listed memory, not a query result: no relevance fields. */
+	entityMemory(memory, body) {
+		const { score: _score, normalizedScore: _normalized, relevanceTier: _tier, federatedScore: _federated, confidence: _confidence, intent: _intent, matchedVia: _matchedVia, depth: _depth, edgeType: _edgeType, ...listed } = memory;
+		return this.annotate(listed, body);
+	}
+	invalidateEntityIndex(memoryBodyId) {
+		this.entityIndexCache.delete(memoryBodyId);
+		this.entityStatusCache.delete(memoryBodyId);
+	}
 	async remember(request, signal) {
 		this.assertWritable();
 		const prepared = this.prepareRemember(request);
@@ -2103,6 +2404,24 @@ var MemorySpacesService = class {
 		}
 		return results;
 	}
+	/**
+	* The memories held under an exact id among the given spaces that can be
+	* read now, asked of the Providers that can look ids up.
+	*/
+	async locate(id, memoryBodyIds, signal) {
+		const exact = required(id, "id", 2e3);
+		const readable = new Map(this.memorySpaces.active().filter((body) => this.isNativeSpace(body) || this.memorySpaces.providerServiceEnabled(body.provider.id)).map((body) => [body.id, body]));
+		const found = [];
+		for (const memoryBodyId of new Set(memoryBodyIds)) {
+			const body = readable.get(memoryBodyId);
+			if (body === void 0) continue;
+			const provider = this.providerFor(body);
+			if (provider.get === void 0) continue;
+			const insight = await provider.get(body, exact, signal);
+			if (insight !== void 0 && insight.id === exact) found.push(this.annotate(insight, body));
+		}
+		return found;
+	}
 	async related(id, depth = 2, edge, signal, memoryBodyId) {
 		const body = this.readSpace(memoryBodyId);
 		const selectedEdge = allowed(edge, EDGE_TYPES, "edge");
@@ -2378,6 +2697,7 @@ var MemorySpacesService = class {
 		};
 	}
 	activateAfterWrite(body, providerChanged) {
+		this.invalidateEntityIndex(body.id);
 		if (!providerChanged) return;
 		if (!body.active) this.memorySpaces.setActive(body.id, true);
 		else this.memorySpaces.touch(body.id);
@@ -2408,7 +2728,9 @@ const EMBEDDING_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
 function processFailureMessage(error, args) {
 	const detail = error instanceof Error ? error.message : String(error);
 	const reason = error instanceof ProcessError ? error.reason : "launch";
-	if (reason === "output-limit") return `mnemon ${args.find((arg) => !arg.startsWith("-")) ?? "command"} stopped: ${detail.replace(/^mnemon /u, "")}`;
+	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."}`;
 }
@@ -2774,6 +3096,8 @@ async function manageMemorySpaces(service, request) {
 			...memoryInputStringArray(input.memoryBodyIds, "memoryBodyIds", 1e4) === void 0 ? {} : { memoryBodyIds: memoryInputStringArray(input.memoryBodyIds, "memoryBodyIds", 1e4) }
 		}, request.signal));
 		case "entities": return managementResult(service, await service.entities(memoryInputText(input.entity, "entity", 500, false), input.limit === void 0 ? void 0 : memoryInputInteger(input.limit, 100, 1, 1e4), request.signal));
+		case "entity-memories": return managementResult(service, await service.entityMemories(memoryInputText(input.entity, "entity", 500), input.offset === void 0 ? void 0 : memoryInputInteger(input.offset, 0, 0, 1e6), input.limit === void 0 ? void 0 : memoryInputInteger(input.limit, 50, 1, 200), request.signal));
+		case "entity-related": return managementResult(service, await service.entityRelated(memoryInputText(input.entity, "entity", 500), input.limit === void 0 ? void 0 : memoryInputInteger(input.limit, 20, 1, 50), request.signal, memoryInputText(input.view, "view", 200, false)));
 		case "search": return managementResult(service, await service.search({
 			query: memoryInputText(input.query, "query", 2e3),
 			...memoryInputText(input.mode, "mode", 20, false) === void 0 ? {} : { mode: memoryInputText(input.mode, "mode", 20, false) },
@@ -2781,7 +3105,8 @@ async function manageMemorySpaces(service, request) {
 			...memoryInputText(input.category, "category", 30, false) === void 0 ? {} : { category: memoryInputText(input.category, "category", 30, false) },
 			...memoryInputText(input.source, "source", 30, false) === void 0 ? {} : { source: memoryInputText(input.source, "source", 30, false) },
 			...memoryInputText(input.intent, "intent", 30, false) === void 0 ? {} : { intent: memoryInputText(input.intent, "intent", 30, false) },
-			...memoryInputStringArray(input.memoryBodyIds, "memoryBodyIds", 1e4) === void 0 ? {} : { memoryBodyIds: memoryInputStringArray(input.memoryBodyIds, "memoryBodyIds", 1e4) }
+			...memoryInputStringArray(input.memoryBodyIds, "memoryBodyIds", 1e4) === void 0 ? {} : { memoryBodyIds: memoryInputStringArray(input.memoryBodyIds, "memoryBodyIds", 1e4) },
+			...input.inspect === true ? { inspect: true } : {}
 		}, request.signal));
 		case "related": return managementResult(service, await service.related(memoryInputText(input.id, "id", 2e3), memoryInputInteger(input.depth, 2, 1, 5), memoryInputText(input.edge, "edge", 30, false), request.signal, memoryInputText(input.memoryBodyId, "memoryBodyId", 300, false)));
 		case "body-reconnect": return managementResult(service, await service.reconnectSpace(memoryInputText(input.memoryBodyId, "memoryBodyId", 300), request.signal));
@@ -3059,6 +3384,34 @@ function createMemorySpacesSource(providerSnapshot, config = {}) {
 				admittedByView.set(viewId, current);
 				while (admittedByView.size > 128) admittedByView.delete(admittedByView.keys().next().value);
 			};
+			/**
+			* The Memory Space an exact id belongs to, for an action or traversal that
+			* names a memory by id. Evidence this View returned decides first, as
+			* before. Otherwise the Providers that can look an id up are asked among
+			* the spaces in `scope`, and a found memory is admitted to this View. An
+			* Agent can so forget what it just wrote, and a delegated worker can act on
+			* an id from its parent's turn (#337). A Provider that cannot look ids up
+			* keeps to evidence: its own call may reach beyond the space named.
+			*/
+			const ownerOf = async (viewId, id, requestedSpace, scope, signal) => {
+				const entries = admittedByView.get(viewId);
+				if (requestedSpace !== void 0) {
+					if (entries?.has(requestedSpace + "/" + id) === true) return requestedSpace;
+				} else {
+					const owners = [...entries?.entries() ?? []].filter(([reference]) => reference.endsWith("/" + id)).map(([, owner]) => owner);
+					if (owners.length > 0) return owners.length === 1 ? owners[0] : void 0;
+				}
+				const candidates = requestedSpace === void 0 ? scope : scope.includes(requestedSpace) ? [requestedSpace] : [];
+				if (candidates.length === 0) return void 0;
+				const found = await service.locate(id, candidates, signal);
+				const owners = [...new Set(found.flatMap((item) => item.memoryBodyId === void 0 ? [] : [item.memoryBodyId]))];
+				if (owners.length !== 1) return void 0;
+				admit(viewId, [{
+					id,
+					memoryBodyId: owners[0]
+				}]);
+				return owners[0];
+			};
 			const evidence = (request, items, unavailable) => {
 				const catalog = request.route.sourceRouteId === "inspect";
 				let remaining = request.route.maxCharacters ?? 16e3;
@@ -3116,15 +3469,15 @@ function createMemorySpacesSource(providerSnapshot, config = {}) {
 			};
 			return {
 				facts(request) {
-					const { active, revision } = sourceState(request.scope);
+					const { active, providerReady, revision } = sourceState(request.scope);
 					const routeIds = [
 						"inspect",
 						...active.some((body) => body.provider.capabilities.search) ? ["recall"] : [],
 						...active.some((body) => body.provider.capabilities.related) ? ["related"] : []
 					];
 					const actionIds = service.config.writeEnabled ? [
-						"manage-spaces",
-						...canRemember ? ["remember"] : [],
+						...providerReady ? ["manage-spaces"] : [],
+						...canRemember && providerReady ? ["remember"] : [],
 						...active.some((body) => body.provider.capabilities.link) ? ["link"] : [],
 						...active.some((body) => body.provider.capabilities.forget) ? ["forget"] : []
 					] : [];
@@ -3145,7 +3498,8 @@ function createMemorySpacesSource(providerSnapshot, config = {}) {
 						actionIds,
 						hints: {
 							activeCount: active.length,
-							providerCount: new Set(active.map((body) => body.provider.id)).size
+							providerCount: new Set(active.map((body) => body.provider.id)).size,
+							archivableCount: active.filter((body) => body.provider.capabilities.remember && body.provider.capabilities.forget && body.provider.capabilities.writeMode === "exact").length
 						}
 					};
 				},
@@ -3229,10 +3583,8 @@ function createMemorySpacesSource(providerSnapshot, config = {}) {
 					if (request.route.sourceRouteId === "related") {
 						const id = memoryInputText(input.id, "id", 2e3);
 						const requestedSpace = memoryInputText(input.memoryBodyId, "memoryBodyId", 300, false);
-						const admitted = admittedByView.get(request.view.id);
-						const owners = [...admitted?.entries() ?? []].filter(([reference]) => reference.endsWith("/" + id)).map(([, bodyId]) => bodyId);
-						const owner = requestedSpace === void 0 ? owners.length === 1 ? owners[0] : void 0 : admitted?.get(requestedSpace + "/" + id);
-						if (owner === void 0) throw new Error("related-memory traversal requires evidence already admitted by this View");
+						const owner = await ownerOf(request.view.id, id, requestedSpace, allowedBodies, request.signal);
+						if (owner === void 0) throw new Error("related-memory traversal requires evidence already admitted by this View, or an id found in a Memory Space it can read");
 						if (!allowedBodies.includes(owner)) throw new Error("related-memory owner is outside this View ReadGrant");
 						const edge = memoryInputText(input.edge, "edge", 30, false);
 						if (edge !== void 0 && !EDGES.has(edge)) throw new Error(`unsupported edge: ${edge}`);
@@ -3249,13 +3601,7 @@ function createMemorySpacesSource(providerSnapshot, config = {}) {
 					const allowedBodies = grantIds(grant);
 					const created = createdByView.get(request.view.id) ?? /* @__PURE__ */ new Set();
 					const writableBodies = writeBodies(request.view.id, grant);
-					const admittedOwner = (id) => {
-						const requestedSpace = memoryInputText(input.memoryBodyId, "memoryBodyId", 300, false);
-						const entries = admittedByView.get(request.view.id);
-						if (requestedSpace !== void 0) return entries?.get(requestedSpace + "/" + id);
-						const owners = [...entries?.entries() ?? []].filter(([reference]) => reference.endsWith("/" + id)).map(([, owner]) => owner);
-						return owners.length === 1 ? owners[0] : void 0;
-					};
+					const admittedOwner = (id) => ownerOf(request.view.id, id, memoryInputText(input.memoryBodyId, "memoryBodyId", 300, false), allowedBodies, request.signal);
 					let result;
 					let bodyId;
 					if (request.offer.sourceActionId === "manage-spaces") {
@@ -3322,9 +3668,9 @@ function createMemorySpacesSource(providerSnapshot, config = {}) {
 					} else if (request.offer.sourceActionId === "link") {
 						const sourceId = memoryInputText(input.sourceId, "sourceId", 2e3);
 						const targetId = memoryInputText(input.targetId, "targetId", 2e3);
-						const sourceSpace = admittedOwner(sourceId);
-						const targetSpace = admittedOwner(targetId);
-						if (sourceSpace === void 0 || targetSpace === void 0 || sourceSpace !== targetSpace || !allowedBodies.includes(sourceSpace)) throw new Error("link requires two evidence items admitted by this View from the same Memory Space");
+						const sourceSpace = await admittedOwner(sourceId);
+						const targetSpace = await admittedOwner(targetId);
+						if (sourceSpace === void 0 || targetSpace === void 0 || sourceSpace !== targetSpace || !allowedBodies.includes(sourceSpace)) throw new Error("link requires two evidence items admitted by this View from the same Memory Space, or two ids found in one Memory Space it can read");
 						bodyId = sourceSpace;
 						const edge = memoryInputText(input.type, "type", 30, false);
 						if (edge !== void 0 && !EDGES.has(edge)) throw new Error(`unsupported edge: ${edge}`);
@@ -3332,8 +3678,8 @@ 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);
-						bodyId = admittedOwner(id);
-						if (bodyId === void 0 || !allowedBodies.includes(bodyId)) throw new Error("forget requires evidence already admitted by this View");
+						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");
 						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(), {