dsh-mnemon 0.5.23 → 0.5.25

package/lib/index.js

@@ -7,7 +7,7 @@ import z from "@deepseek-ai/schemastery";
 import { basename, delimiter, dirname, isAbsolute, join, normalize, resolve } from "node:path";
 import { resolveEmbedding, resolvePersistenceStrategy, resolveRecallQuality } from "dsh-mnemon-source-memory-spaces";
 import { createHash, randomUUID } from "node:crypto";
-import { accessSync, closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { strToU8, unzipSync, zipSync } from "fflate";
 import { DOCUMENTS_ACTIVE_LIMIT_BYTES, DOCUMENTS_VERSION } from "dsh-mnemon-source-documents/contracts";
@@ -862,6 +862,33 @@ function readCurrentRuntime(root, limits = RUNTIME_MEMORY_LIMITS) {
 	const path = join(root, "runtime", "memories.json");
 	return existsSync(path) ? parseRuntime(JSON.parse(readFileSync(path, "utf8")), limits) : emptyRuntime();
 }
+/**
+* A Pack carries no local archive: the one MEMORY.md wrote while no Memory Space
+* could take its entries holds their only copy, so an import keeps it (#336).
+* Its files and folders are carried; a link is neither carried nor followed.
+*/
+function keepRuntimeArchive(root, stagedRuntime) {
+	const copy = (from, to) => {
+		let stat;
+		try {
+			stat = lstatSync(from);
+		} catch {
+			return;
+		}
+		if (stat.isSymbolicLink()) return;
+		if (stat.isFile()) {
+			copyFileSync(from, to);
+			chmodSync(to, 384);
+		} else if (stat.isDirectory()) {
+			mkdirSync(to, {
+				recursive: true,
+				mode: 448
+			});
+			for (const name of readdirSync(from)) copy(join(from, name), join(to, name));
+		}
+	};
+	copy(join(root, "runtime", "archived"), join(stagedRuntime, "archived"));
+}
 function writeRuntime(directory, file) {
 	mkdirSync(directory, {
 		recursive: true,
@@ -1120,6 +1147,7 @@ function stageImport(root, pack, components, mode, runtimeLimits) {
 		if (components.includes("runtime")) {
 			const runtime = mode === "merge" ? mergeRuntime(root, pack, runtimeLimits) : parseRuntime(json$1(pack.files["payload/runtime/memories.json"], "payload/runtime/memories.json"), runtimeLimits);
 			writeRuntime(join(staging, "runtime"), runtime);
+			keepRuntimeArchive(root, join(staging, "runtime"));
 		}
 		if (components.includes("documents")) {
 			const documents = mode === "merge" ? mergeDocuments(root, pack) : archiveDocuments(pack);
@@ -3437,6 +3465,14 @@ function pendingMutationContext(plan) {
 		...plan.excluded === void 0 ? [] : [`- Matched committed entry: excluded by the host because it will be ${plan.action === "replace" ? "replaced" : "removed"}`]
 	].join("\n");
 }
+/**
+* A space that can take a MEMORY.md archive or a Document's index: active, its
+* Provider enabled and ready, with exact writes and safe forget. A Mnemon Native
+* space stays listed, and active, while its CLI is missing; it takes no writes then.
+*/
+function archivableSpace(directory, body) {
+	return body.active && body.providerEnabled !== false && body.provider.capabilities.remember === true && body.provider.capabilities.writeMode === "exact" && body.provider.capabilities.forget === true && directory.providers?.find((provider) => provider.id === body.provider.id)?.serviceConfigured !== false;
+}
 function compactedBudget(plan) {
 	const pendingBytes = plan.pending === void 0 ? 0 : Buffer.byteLength(plan.pending.content, "utf8");
 	const separatorBytes = plan.pending === void 0 || plan.entries.length === 0 ? 0 : Buffer.byteLength(RUNTIME_ENTRY_DELIMITER, "utf8");
@@ -3595,6 +3631,22 @@ function destinationFromCommittedMutation(result, memoryBodyId, content) {
 		digest
 	};
 }
+/**
+* The memory a skipped write names as already holding exactly this text, when
+* its receipt carries that memory's id and stored text. Anything less proves
+* nothing, and the caller verifies by search instead.
+*/
+function skippedExactDestination(result, memoryBodyId, content) {
+	const value = optionalObject(result);
+	const id = typeof value?.id === "string" ? value.id.trim() : "";
+	if (id === "" || value?.content !== content) return void 0;
+	if (value.memoryBodyId !== void 0 && value.memoryBodyId !== memoryBodyId) return void 0;
+	return {
+		layerId: "memory-spaces",
+		reference: `memory-space:${encodeURIComponent(memoryBodyId)}/item:${encodeURIComponent(id)}`,
+		digest: sha256(content)
+	};
+}
 function mutationStates(result) {
 	const value = optionalObject(result);
 	return [value?.action, value?.status].filter((entry) => typeof entry === "string").map((entry) => entry.trim().toLocaleLowerCase());
@@ -3892,11 +3944,13 @@ var MnemonSubagentCoordinator = class {
 				commit: () => runtime.mutate("mutate", request, signal),
 				memorySpaces: async () => {
 					if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
-					assertParticipation(graph.config, "memory-spaces", "write", "automatic");
+					if (!allowsParticipation(graph.config, "memory-spaces", "write", "automatic") || !lease.generation.sourceInstances().some((source) => source.sourceTypeId === "memory-spaces")) return void 0;
 					const source = graph.source("memory-spaces", scope).forGeneration(lease.generation);
+					const { sourceInstanceKey } = await source.identity();
 					return {
 						source,
-						cleanup: source
+						cleanup: source,
+						elsewhere: await this.archivableElsewhere(graph, scope, lease.generation, sourceInstanceKey, signal)
 					};
 				},
 				model: (...args) => this.runtimeModel(scope, parent, signal, ...args)
@@ -3946,7 +4000,7 @@ var MnemonSubagentCoordinator = class {
 				},
 				memorySpaces: async () => {
 					if (!authorize()) throw new Error("Runtime capacity maintenance is no longer authorized");
-					return this.runtimeArchiveSource(graph, turn.scope, turn.view, lease.generation, turn);
+					return this.runtimeArchiveSource(graph, turn.scope, turn.view, lease.generation, turn, signal);
 				},
 				model: (...args) => this.runtimeModel(turn.scope, parent, signal, ...args)
 			}, input, signal);
@@ -3992,7 +4046,7 @@ var MnemonSubagentCoordinator = class {
 						scenario: "management.runtime-capacity",
 						budget: DEFAULT_MEMORY_VIEW_BUDGET
 					}, signal);
-					return this.runtimeArchiveSource(graph, request.scope, view, generation);
+					return this.runtimeArchiveSource(graph, request.scope, view, generation, void 0, signal);
 				},
 				model: (...args) => this.runtimeModel(request.scope, void 0, signal, ...args)
 			}, request.input, signal);
@@ -4006,11 +4060,14 @@ var MnemonSubagentCoordinator = class {
 			lease.release();
 		}
 	}
-	async runtimeArchiveSource(graph, scope, view, generation, turn) {
+	async runtimeArchiveSource(graph, scope, view, generation, turn, signal) {
 		if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
-		assertParticipation(graph.config, "memory-spaces", "write", "automatic");
+		if (!allowsParticipation(graph.config, "memory-spaces", "write", "automatic")) return void 0;
 		const candidates = generation.sourceInstances().filter((source) => source.sourceTypeId === "memory-spaces" && view.actionOffers.some((offer) => offer.sourceInstanceKey === source.sourceInstanceKey && offer.sourceActionId === "remember" && offer.authority === void 0));
-		if (candidates.length === 0) throw new Error("Source Action is not offered by the current View: memory-spaces/remember");
+		if (candidates.length === 0) {
+			if (await this.noArchivableMemorySpace(graph, scope, generation, signal)) return void 0;
+			throw new Error("Source Action is not offered by the current View: memory-spaces/remember");
+		}
 		if (candidates.length !== 1) throw new Error("Runtime archival requires one unambiguous writable Memory Spaces Source");
 		const cleanup = graph.source("memory-spaces", scope).forInstance(candidates[0].sourceInstanceKey).forGeneration(generation);
 		let source = cleanup;
@@ -4024,6 +4081,46 @@ var MnemonSubagentCoordinator = class {
 			writeScope: {
 				viewId: view.id,
 				grant
+			},
+			elsewhere: await this.archivableElsewhere(graph, scope, generation, candidates[0].sourceInstanceKey, signal)
+		};
+	}
+	/**
+	* MEMORY.md keeps working without a Memory Space to archive into: the Runtime
+	* Source moves the entries compaction leaves out to its local archive, as exact
+	* text, in the same commit as the compaction and the pending write (#336).
+	*/
+	async archiveRuntimeLocally(context, request, plan, reason, signal) {
+		signal.throwIfAborted();
+		if (plan.localArchive !== true) throw new Error(`runtime memory archival found no Memory Space that can take the archive (${reason}), and this Runtime Source cannot archive locally; pending write was not committed and existing runtime entries are unchanged; update dsh-mnemon-source-runtime, activate a supported Memory Space, or increase runtimeMemory.memoryLimitBytes`);
+		context.assertWritable?.();
+		const runId = `host-${randomUUID()}`;
+		const compacted = plan.entries.map(({ content, importance, branches }) => ({
+			content,
+			importance,
+			...branches === void 0 ? {} : { branches }
+		}));
+		const mutation = await context.runtime.mutateResult("compact-and-mutate", {
+			revision: plan.revision,
+			mutation: request,
+			compacted,
+			maxBytes: compactedBudget(plan),
+			archive: "local"
+		}, signal);
+		const archived = mutation.value.archived?.entries ?? 0;
+		this.counters.migrations += 1;
+		this.counters.lastRunId = runId;
+		this.counters.lastOperation = "migration";
+		this.counters.lastAt = (/* @__PURE__ */ new Date()).toISOString();
+		return {
+			...mutation.value,
+			revision: mutation.revision,
+			maintenance: {
+				kind: "local-archive",
+				runId,
+				provider: "host",
+				summary: `Moved ${archived} MEMORY.md ${archived === 1 ? "entry" : "entries"} to the local archive${mutation.value.archived === void 0 ? "" : ` ${mutation.value.archived.path}`}, since ${reason}.`,
+				memoryBodyIds: []
 			}
 		};
 	}
@@ -4160,15 +4257,22 @@ ${naturalRequest(request)}`;
 			const document = await controller.read("document", { id }, signal);
 			if (document.status !== "active") throw new Error("only active documents can be archived");
 			const source = documentMigrationSource(document);
-			const memoryService = (await this.assertAutomaticMemoryWrite(parent)).forGeneration(lease.generation);
+			const indexSpaces = await this.documentIndexSpaces(parent, lease.generation, signal);
+			if (indexSpaces === void 0) return this.archiveDocumentLocally(controller, document, "no Memory Spaces layer takes writes here", signal);
+			const memoryService = indexSpaces.forGeneration(lease.generation);
 			const identity = await memoryService.identity();
 			const cleanup = graph.source("memory-spaces", agentScope(parent, graph.config)).forInstance(identity.sourceInstanceKey).forGeneration(lease.generation);
 			const grant = authority?.context.view.readGrants.find((grant) => grant.sourceInstanceKey === identity.sourceInstanceKey && grant.schema === "dsh-mnemon.memory-spaces/v1");
 			if (authority !== void 0 && grant === void 0) throw new Error("document archive requires a Memory Space namespace grant");
 			const allowed = grant === void 0 ? void 0 : new Set(strings(object$6(grant.value).memoryBodyIds));
-			const eligible = (body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember && body.provider.capabilities.forget && body.provider.capabilities.writeMode === "exact" && (allowed === void 0 || allowed.has(body.id));
-			const bodies = (await memoryService.read("body-directory", null, signal)).items.filter(eligible);
-			if (bodies.length === 0) throw new Error("document archive requires an existing active Memory Space with exact writes and safe forget");
+			const directory = await memoryService.read("body-directory", null, signal);
+			const indexable = (body) => archivableSpace(directory, body);
+			const eligible = (body) => indexable(body) && (allowed === void 0 || allowed.has(body.id));
+			const bodies = directory.items.filter(eligible);
+			if (bodies.length === 0) {
+				if (!directory.items.some(indexable) && !await this.archivableElsewhere(graph, agentScope(parent, graph.config), lease.generation, identity.sourceInstanceKey, signal)) return this.archiveDocumentLocally(controller, document, "no Memory Space can take its index", signal);
+				throw new Error("document archive requires an existing active Memory Space with exact writes and safe forget");
+			}
 			const { provider, runId, result } = await this.delegate(parent, "document-archive", "Plan managed document archive", documentArchivePrompt(document, source, bodies), [], DOCUMENT_ARCHIVE_SCHEMA, signal, "spawn", DOCUMENT_ARCHIVE_PERSONA);
 			const value = object$6(result.structured);
 			const summary = typeof value.summary === "string" ? value.summary.trim() : "";
@@ -4220,18 +4324,22 @@ ${naturalRequest(request)}`;
 					if (written.length !== 1) throw new Error("document archive requires exactly one index receipt");
 					if (isNew && receiptId !== void 0) destination = destinationFromCommittedMutation(receipt, memoryBodyId, content);
 					else if (states.includes("skipped")) {
-						const exact = (await memoryService.read("search", {
-							query: document.contentHash,
-							mode: "keyword",
-							limit: 50,
-							memoryBodyIds: [memoryBodyId]
-						}, signal)).results.find((item) => item.memoryBodyId === memoryBodyId && item.id === receiptId && item.content === content);
-						if (exact === void 0) throw new Error(`document archive skipped index lacks exact durable evidence in Memory Space ${memoryBodyId}`);
-						destination = {
-							layerId: "memory-spaces",
-							reference: `memory-space:${encodeURIComponent(memoryBodyId)}/item:${encodeURIComponent(exact.id)}`,
-							digest: sha256(exact.content)
-						};
+						const named = skippedExactDestination(receipt, memoryBodyId, content);
+						if (named !== void 0) destination = named;
+						else {
+							const exact = (await memoryService.read("search", {
+								query: document.contentHash,
+								mode: "keyword",
+								limit: 50,
+								memoryBodyIds: [memoryBodyId]
+							}, signal)).results.find((item) => item.memoryBodyId === memoryBodyId && item.id === receiptId && item.content === content);
+							if (exact === void 0) throw new Error(`document archive skipped index lacks exact durable evidence in Memory Space ${memoryBodyId}`);
+							destination = {
+								layerId: "memory-spaces",
+								reference: `memory-space:${encodeURIComponent(memoryBodyId)}/item:${encodeURIComponent(exact.id)}`,
+								digest: sha256(exact.content)
+							};
+						}
 					} else throw new Error(`document archive received no reversible committed index receipt in Memory Space ${memoryBodyId}`);
 				}
 				signal.throwIfAborted();
@@ -4293,6 +4401,7 @@ ${naturalRequest(request)}`;
 		if (plan.entries.length === 0) throw new Error("runtime memory capacity was exceeded without entries available for maintenance");
 		if (request.target === "user") return this.compactUserAndCommit(context, request, plan, signal);
 		const archive = await context.memorySpaces();
+		if (archive === void 0) return this.archiveRuntimeLocally(context, request, plan, "no Memory Space takes automatic writes here", signal);
 		const memoryService = archive.source;
 		let allowed = archive.memoryBodyIds;
 		const readDirectory = async () => {
@@ -4306,13 +4415,16 @@ ${naturalRequest(request)}`;
 			return catalog;
 		};
 		const catalog = await readDirectory();
-		const writable = (body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember === true && (allowed === void 0 || allowed.has(body.id));
-		const eligible = (body) => writable(body) && body.provider.capabilities.writeMode === "exact" && body.provider.capabilities.forget === true;
+		const ready = (body) => catalog.providers?.find((provider) => provider.id === body.provider.id)?.serviceConfigured !== false;
+		const writable = (body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember === true && ready(body) && (allowed === void 0 || allowed.has(body.id));
+		const exact = (body) => body.provider.capabilities.writeMode === "exact" && body.provider.capabilities.forget === true;
+		const eligible = (body) => writable(body) && exact(body);
 		const eligibleBodies = catalog.items.filter(eligible);
 		if (eligibleBodies.length === 0) {
 			const writableBodies = catalog.items.filter(writable);
 			const unsupported = writableBodies.map((body) => `${body.id} (provider=${body.provider.id}, writeMode=${body.provider.capabilities.writeMode}, forget=${body.provider.capabilities.forget})`).join(", ");
 			const reason = catalog.items.length === 0 ? "Memory Space body-directory is empty" : allowed?.size === 0 ? "current View write scope is empty" : allowed !== void 0 && catalog.items.some((body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember && !allowed?.has(body.id)) && writableBodies.length === 0 ? "current View write scope excludes the active writable Memory Spaces" : writableBodies.length === 0 ? "no active writable Memory Space in the authorized scope" : "authorized destinations lack exact writes or safe forget";
+			if (!catalog.items.some((body) => archivableSpace(catalog, body)) && archive.elsewhere !== true) return this.archiveRuntimeLocally(context, request, plan, `${reason}${unsupported === "" ? "" : ` (${unsupported})`}`, signal);
 			const scope = archive.writeScope === void 0 ? "management" : `${archive.writeScope.grant.sourceInstanceKey}/${catalog.writeScope === void 0 ? "pinned-read" : "source-write"}`;
 			throw new Error(`runtime memory archival requires an existing active writable Memory Space with exact writes and safe forget; ${reason}; scope=${scope}, catalog=${catalog.items.length}, authorized=${allowed?.size ?? "management"}, writable=${writableBodies.length}; pending write was not committed and existing runtime entries are unchanged; retry the same request in a new turn after activating a supported authorized Memory Space, or increase runtimeMemory.memoryLimitBytes${unsupported === "" ? "" : `; unsupported destinations: ${unsupported}`}`);
 		}
@@ -4563,12 +4675,18 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 		const committed = destinationFromCommittedMutation(result, memoryBodyId, entry.content);
 		if (committed !== void 0) return committed;
 		if (!mutationStates(result).includes("skipped")) throw new Error(`runtime archive write did not commit synchronously for Memory Space ${memoryBodyId}`);
-		const exact = (await service.read("search", {
+		const named = skippedExactDestination(result, memoryBodyId, entry.content);
+		if (named !== void 0) return named;
+		const recalled = await service.read("search", {
 			query: entry.content.slice(0, 500),
 			limit: 20,
 			memoryBodyIds: [memoryBodyId]
-		}, signal)).results.find((candidate) => candidate.memoryBodyId === memoryBodyId && candidate.content.trim() === entry.content);
-		if (exact === void 0) throw new Error(`runtime archive skipped an entry without exact durable recall evidence in Memory Space ${memoryBodyId}`);
+		}, signal);
+		const exact = recalled.results.find((candidate) => candidate.memoryBodyId === memoryBodyId && candidate.content.trim() === entry.content);
+		if (exact === void 0) {
+			const unavailable = recalled.sources?.find((source) => source.status === "unavailable");
+			throw new Error(`runtime archive skipped an entry without exact durable recall evidence in Memory Space ${memoryBodyId}: ${unavailable === void 0 ? `its search returned ${recalled.results.length} results, none with that exact text` : `its search was unavailable (${safeFailureDetail(unavailable.hint ?? "no detail")})`}`);
+		}
 		return {
 			layerId: "memory-spaces",
 			reference: `memory-space:${encodeURIComponent(memoryBodyId)}/item:${encodeURIComponent(exact.id)}`,
@@ -4832,6 +4950,68 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 		await source.assertActionOffered(actionId, (offer) => authority.graph.config.writeEnabled && offer.authority === void 0);
 		return source;
 	}
+	/**
+	* The Memory Spaces Source a Document archive indexes into, or undefined when
+	* that layer is off, not installed, takes no automatic writes, or has no space
+	* anywhere that could take the index (#336). A space this View does not offer
+	* keeps the refusal, as before.
+	*/
+	async documentIndexSpaces(parent, generation, signal) {
+		const graph = this.runtimeSource.forAgent(parent);
+		if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
+		if (!allowsParticipation(graph.config, "memory-spaces", "write", "automatic")) return void 0;
+		const installed = generation.sourceInstances().filter((source) => source.sourceTypeId === "memory-spaces");
+		if (installed.length === 0) return void 0;
+		const authority = this.turnAuthority(parent, false);
+		if (authority !== void 0 && !authority.context.view.actionOffers.some((offer) => offer.sourceActionId === "remember" && offer.authority === void 0 && installed.some((source) => source.sourceInstanceKey === offer.sourceInstanceKey)) && await this.noArchivableMemorySpace(graph, agentScope(parent, graph.config), generation, signal)) return void 0;
+		return this.writableSourceFor(parent, "memory-spaces", "remember");
+	}
+	/** Whether a Memory Spaces Source other than the one in use lists a space that could take the archive. */
+	async archivableElsewhere(graph, scope, generation, sourceInstanceKey, signal) {
+		if (!generation.sourceInstances().some((source) => source.sourceTypeId === "memory-spaces" && source.sourceInstanceKey !== sourceInstanceKey)) return false;
+		return !await this.noArchivableMemorySpace(graph, scope, generation, signal, sourceInstanceKey);
+	}
+	/**
+	* True only when no installed Memory Spaces Source lists a space that could take
+	* an archive (#336). A directory that cannot be read counts as one that could:
+	* the caller then refuses as before, and nothing leaves working memory.
+	*/
+	async noArchivableMemorySpace(graph, scope, generation, signal, except) {
+		for (const instance of generation.sourceInstances().filter((source) => source.sourceTypeId === "memory-spaces" && source.sourceInstanceKey !== except)) try {
+			const directory = await graph.source("memory-spaces", scope).forInstance(instance.sourceInstanceKey).forGeneration(generation).read("body-directory", null, signal);
+			if (directory.items.some((body) => archivableSpace(directory, body))) return false;
+		} catch {
+			signal?.throwIfAborted();
+			return false;
+		}
+		return true;
+	}
+	/** A Project Document archived without a Mnemon index keeps its original under .mnemon/documents/archived. */
+	async archiveDocumentLocally(controller, document, reason, signal) {
+		signal.throwIfAborted();
+		const summary = `Archived locally without a Mnemon index, since ${reason}.`;
+		const archived = await controller.mutate("archive", {
+			id: document.id,
+			documentRevision: document.revision,
+			summary,
+			memoryBodyIds: []
+		}, signal);
+		const runId = `host-${randomUUID()}`;
+		this.counters.documentArchives += 1;
+		this.counters.lastRunId = runId;
+		this.counters.lastOperation = "document-archive";
+		this.counters.lastAt = (/* @__PURE__ */ new Date()).toISOString();
+		return {
+			...archived,
+			maintenance: {
+				runId,
+				provider: "host",
+				summary,
+				memoryBodyIds: [],
+				archivedDocumentIds: [document.id]
+			}
+		};
+	}
 	async assertAutomaticMemoryWrite(parent) {
 		const graph = this.runtimeSource.forAgent(parent);
 		if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
@@ -5789,7 +5969,7 @@ var MnemonLifecycle = class {
 	};
 	/** Creation ids reserved before DSH publishes clean task-root Agents. */
 	taskAgentIds = /* @__PURE__ */ new Set();
-	/** Bounded process-local replay fence for finalized-message write actions. */
+	/** Bounded process-local replay fence for finalized-message write actions: the latest text per message. */
 	supervisedWritebacks = /* @__PURE__ */ new Map();
 	constructor(ctx, coordinator, config, runtimeSource) {
 		this.ctx = ctx;
@@ -6055,15 +6235,13 @@ var MnemonLifecycle = class {
 		if (normalizedKey === void 0 || normalizedKey === "") return execute();
 		const replayKey = `${replayScope}\u0000${normalizedKey}`;
 		const existing = this.supervisedWritebacks.get(replayKey);
-		if (existing !== void 0) {
-			if (existing.content !== normalizedContent) throw new Error("idempotency key was already used for different content");
-			return existing.result;
-		}
-		if (this.supervisedWritebacks.size >= 256) {
+		if (existing?.content === normalizedContent) return existing.result;
+		if (existing === void 0 && this.supervisedWritebacks.size >= 256) {
 			const oldest = this.supervisedWritebacks.keys().next().value;
 			if (oldest !== void 0) this.supervisedWritebacks.delete(oldest);
 		}
 		const result = execute();
+		this.supervisedWritebacks.delete(replayKey);
 		this.supervisedWritebacks.set(replayKey, {
 			content: normalizedContent,
 			result
@@ -7212,7 +7390,6 @@ async function assisted(runtime, lifecycle, typeId, operation, input, signal, ta
 	if (typeId === "documents") {
 		if (operation === "archive") {
 			requireCapability(runtime, typeId, "archive");
-			requireCapability(runtime, "memory-spaces", "write");
 			return lifecycle.archiveDocument(sessionId, String(input.id ?? ""), workspaceRoot, signal);
 		}
 		if (operation === "mutate") {
@@ -8147,7 +8324,6 @@ function registerTools(ctx, runtimeSource, coordinator) {
 			const agent = requireAgent(exec);
 			if (args.action === "archive") {
 				requireSource(exec, "documents", "archive");
-				requireSource(exec, "memory-spaces", "write");
 				if (isSubagent(agent)) throw new Error("idle document workers cannot cold-archive directly");
 				if (args.id === void 0) throw new Error("document id is required for archive");
 				return coordinator.archiveDocument(agent, args.id, exec.signal);

package/lib/{starter-resolution-B0Wj3X3R.js → starter-resolution-UcTGyjgm.js}

@@ -10,15 +10,15 @@ var dependencies = {
 	"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.8",
+	"dsh-mnemon-provider-mnemon-native": "0.5.9",
 	"dsh-mnemon-provider-openviking": "0.5.7",
 	"dsh-mnemon-provider-retaindb": "0.5.5",
 	"dsh-mnemon-provider-supermemory": "0.5.5",
-	"dsh-mnemon-source-documents": "0.5.9",
-	"dsh-mnemon-source-memory-spaces": "0.5.15",
-	"dsh-mnemon-source-runtime": "0.5.12",
+	"dsh-mnemon-source-documents": "0.5.10",
+	"dsh-mnemon-source-memory-spaces": "0.5.17",
+	"dsh-mnemon-source-runtime": "0.5.13",
 	"dsh-mnemon-strategy-auto-capture": "0.5.5",
-	"dsh-mnemon-strategy-default-three-tier": "0.5.7",
+	"dsh-mnemon-strategy-default-three-tier": "0.5.8",
 	"dsh-mnemon-strategy-general": "0.5.1",
 	"dsh-mnemon-strategy-light-context": "0.5.5",
 	"dsh-mnemon-strategy-scoped": "0.5.5",

package/lib/starter.js

@@ -1,4 +1,4 @@
-import { t as prepareStarterResolution } from "./starter-resolution-B0Wj3X3R.js";
+import { t as prepareStarterResolution } from "./starter-resolution-UcTGyjgm.js";
 //#region src/starter.ts
 const name = "dsh-mnemon-starter";
 const provide = ["mnemonStarterReady"];

package/lib/types/src/client/locales.d.ts

@@ -102,6 +102,7 @@ export declare const zh: {
     'receipt.unfinished': string;
     'receipt.failed': string;
     'receipt.view': string;
+    'receipt.viewRuntime': string;
     'taskAgent.ready': string;
     'taskAgent.unavailable': string;
     'saveAction.button': string;
@@ -116,6 +117,31 @@ export declare const zh: {
     'saveAction.submitting': string;
     'saveAction.readOnly': string;
     'saveAction.close': string;
+    'saveAction.hintDirect': string;
+    'saveAction.to': string;
+    'saveAction.to.agent': string;
+    'saveAction.to.agentDetail': string;
+    'saveAction.to.memory': string;
+    'saveAction.to.user': string;
+    'saveAction.to.space': string;
+    'saveAction.save': string;
+    'saveAction.saving': string;
+    'saveAction.saved.runtime': string;
+    'saveAction.saved.runtimeMaintained': string;
+    'saveAction.saved.space': string;
+    'saveAction.saved.spacePending': string;
+    'saveAction.saved.spaceOther': string;
+    'saveAction.saved.duplicate': string;
+    'saveAction.unavailable': string;
+    'saveAction.place.delimiter': string;
+    'saveAction.place.tooLong': string;
+    'saveAction.place.orAgent': string;
+    'saveAction.place.full': string;
+    'saveAction.place.fullAll': string;
+    'saveAction.place.userCondense': string;
+    'saveAction.place.userTooLong': string;
+    'saveAction.place.userFull': string;
+    'saveAction.noPlace': string;
     'readSources.all': string;
     'readSources.mode.search': string;
     'readSources.mode.graph': string;
@@ -887,6 +913,18 @@ export declare const zh: {
     "entities.selectText": string;
     "entities.emptyTitle": string;
     "entities.emptyText": string;
+    "entities.railLoading": string;
+    "entities.memoriesHint": string;
+    "entities.relatedTitle": string;
+    "entities.relatedHint": string;
+    "entities.findRelated": string;
+    "entities.hideRelated": string;
+    "entities.noCarrying": string;
+    "entities.noRelated": string;
+    "entities.retry": string;
+    "entities.sourceReady": string;
+    "entities.sourcePartial": string;
+    "readSources.status.loading": string;
     "remember.title": string;
     "remember.description": string;
     "remember.readOnlyTitle": string;
@@ -968,6 +1006,7 @@ export declare const zh: {
     "documents.updated": string;
     "documents.updatedAfterArchive": string;
     "documents.archived": string;
+    "documents.archivedLocally": string;
     "documents.list": string;
     "documents.activeList": string;
     "documents.archiveList": string;
@@ -987,6 +1026,7 @@ export declare const zh: {
     "documents.hash": string;
     "documents.size": string;
     "documents.archiveReceipt": string;
+    "documents.archiveNote": string;
     "documents.archiveTitle": string;
     "documents.archiveDescription": string;
     "documents.archive": string;
@@ -1036,6 +1076,7 @@ export declare const zh: {
     "runtime.result.remove": string;
     "runtime.result.maintenance": string;
     "runtime.result.localCompaction": string;
+    "runtime.result.localArchive": string;
     "runtime.readOnly": string;
     "runtime.footnote": string;
 };

package/lib/types/src/client/page-controls.d.ts

@@ -48,6 +48,7 @@ export declare function WriteReceipt(props: {
     error?: string | undefined;
     t?: MnemonTranslate | undefined;
     onView?: (() => void) | undefined;
+    viewLabel?: string | undefined;
 }): JSX.Element;
 /** Whether a task Agent can take a write now. */
 export declare function TaskAgentTag(props: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon",
-  "version": "0.5.23",
+  "version": "0.5.25",
   "description": "Composable, view-based memory for DeepSeek Harness. Pluggable sources and strategies, with layered memory out of the box.",
   "keywords": [
     "deepseek-harness",
@@ -157,15 +157,15 @@
     "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.8",
+    "dsh-mnemon-provider-mnemon-native": "0.5.9",
     "dsh-mnemon-provider-openviking": "0.5.7",
     "dsh-mnemon-provider-retaindb": "0.5.5",
     "dsh-mnemon-provider-supermemory": "0.5.5",
-    "dsh-mnemon-source-documents": "0.5.9",
-    "dsh-mnemon-source-memory-spaces": "0.5.15",
-    "dsh-mnemon-source-runtime": "0.5.12",
+    "dsh-mnemon-source-documents": "0.5.10",
+    "dsh-mnemon-source-memory-spaces": "0.5.17",
+    "dsh-mnemon-source-runtime": "0.5.13",
     "dsh-mnemon-strategy-auto-capture": "0.5.5",
-    "dsh-mnemon-strategy-default-three-tier": "0.5.7",
+    "dsh-mnemon-strategy-default-three-tier": "0.5.8",
     "dsh-mnemon-strategy-general": "0.5.1",
     "dsh-mnemon-strategy-light-context": "0.5.5",
     "dsh-mnemon-strategy-scoped": "0.5.5",