dsh-mnemon 0.5.7 → 0.5.9

package/lib/index.js

@@ -13,6 +13,7 @@ import { strToU8, unzipSync, zipSync } from "fflate";
 import { DOCUMENTS_ACTIVE_LIMIT_BYTES, DOCUMENTS_VERSION } from "dsh-mnemon-source-documents/contracts";
 import { RUNTIME_ENTRY_DELIMITER, RUNTIME_MEMORY_LIMITS, RUNTIME_MEMORY_VERSION } from "dsh-mnemon-source-runtime/contracts";
 import { threeTierActionWorkflow } from "dsh-mnemon-strategy-default-three-tier/extension-sdk";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { fileURLToPath } from "node:url";
 import { findMnemonCommand, mnemonNpmLauncher, nodeLauncherEnvironment } from "dsh-mnemon-source-memory-spaces/native-cli";
 import { spawn } from "node:child_process";
@@ -2611,6 +2612,86 @@ function hostSessionEventAt(session, seq) {
 	return hostSessionEvents(session)[seq];
 }
 //#endregion
+//#region src/host/review-tools.ts
+const startingReview = new AsyncLocalStorage();
+/**
+* DSH restrict() filters inherited capabilities, leaving own-scope plugin tools
+* visible. Attach its monotonic execution guard during publication, before a
+* review child can run. Async context attributes concurrent provider starts;
+* public registry ownership verifies the exact causal parent.
+*/
+async function startGuardedReview(host, parent, toolNames, start) {
+	const agents = host.agents;
+	if (typeof agents?.isOwnedBy !== "function") throw new Error("Mnemon review requires DSH Agent ownership and scoped tool guard support");
+	const pending = Symbol("Mnemon review publication");
+	const allowed = new Set(toolNames);
+	const guards = /* @__PURE__ */ new Map();
+	let attachmentError;
+	let run;
+	const listener = host.on("agent/created", (({ agent }) => {
+		if (startingReview.getStore() !== pending || !agents.isOwnedBy(agent.id, parent)) return;
+		try {
+			const tools = agent.ctx.tools;
+			if (typeof tools?.guard !== "function") throw new Error("Mnemon review requires DSH scoped tool guard support");
+			const dispose = tools.guard((execution) => {
+				if (execution.name === "run_code" || execution.name !== void 0 && allowed.has(execution.name)) return;
+				return `Mnemon review cannot execute ${JSON.stringify(execution.name)}; reuse the inherited checkpoint and bounded Document search.`;
+			});
+			if (typeof dispose !== "function") throw new Error("Mnemon review tool guard did not return a disposer");
+			guards.set(agent, dispose);
+		} catch (error) {
+			attachmentError = error;
+			throw error;
+		}
+	}));
+	if (typeof listener !== "function") throw new Error("Mnemon review creation observer did not return a disposer");
+	let disposeObserver = listener;
+	const closeObserver = async () => {
+		const dispose = disposeObserver;
+		disposeObserver = void 0;
+		await dispose?.();
+	};
+	const release = async () => {
+		const disposers = [...guards.values()];
+		guards.clear();
+		const failed = (await Promise.allSettled(disposers.map(async (dispose) => {
+			await dispose();
+		}))).filter((outcome) => outcome.status === "rejected");
+		if (failed.length) throw new AggregateError(failed.map((outcome) => outcome.reason), "Mnemon review guard cleanup failed");
+	};
+	try {
+		run = await startingReview.run(pending, start);
+		if (attachmentError !== void 0) throw attachmentError;
+		const child = run.localAgent;
+		if (child === void 0 || !guards.has(child)) throw new Error("Mnemon review provider did not publish a local child with its scoped tool guard");
+		await closeObserver();
+		const active = run;
+		return {
+			id: active.id,
+			localAgent: child,
+			result: active.result,
+			async dispose() {
+				try {
+					await active.dispose();
+				} finally {
+					await release();
+				}
+			}
+		};
+	} catch (error) {
+		try {
+			await closeObserver();
+		} catch {}
+		try {
+			await run?.dispose();
+		} catch {}
+		try {
+			await release();
+		} catch {}
+		throw error;
+	}
+}
+//#endregion
 //#region src/host/subagent.ts
 function evidenceInsights(evidence) {
 	return evidence.items.map((item) => {
@@ -2643,7 +2724,22 @@ const REVIEW_TOOLS = [
 	"mnemon_runtime_memory",
 	"mnemon_document_create"
 ];
-const RESULT_TOOL_PREFIX = "mnemon_subagent_result_";
+const RESULT_TOOL_NAME = "mnemon_subagent_result";
+const RESULT_TOOL_INPUT_SCHEMA = {
+	type: "object",
+	properties: {
+		requestId: {
+			type: "string",
+			minLength: 1
+		},
+		result: {
+			type: "object",
+			additionalProperties: true
+		}
+	},
+	required: ["requestId", "result"],
+	additionalProperties: false
+};
 const RUNTIME_ROUTE_ENTRY_CHARACTERS = 384;
 const RUNTIME_ROUTE_CHUNK_CHARACTERS = 1024;
 const RESULT_TOOL_OUTPUT_SCHEMA = {
@@ -3026,8 +3122,8 @@ ${entries.length === 0 ? "(empty)" : entries.map((entry, index) => `${index + 1}
 function runtimeRoutingExcerpt(value) {
 	if (value.length <= RUNTIME_ROUTE_ENTRY_CHARACTERS) return value;
 	const marker = "\n[... host-truncated routing excerpt ...]\n";
-	const prefix = Math.ceil(RUNTIME_ROUTE_ENTRY_CHARACTERS * .7);
-	return `${value.slice(0, prefix)}${marker}${value.slice(-115)}`;
+	const prefix = Math.ceil(342 * .7);
+	return `${value.slice(0, prefix)}${marker}${value.slice(-102)}`;
 }
 function runtimeRouteChunks(entries) {
 	const chunks = [];
@@ -3100,6 +3196,8 @@ function metadataSampleText(sample) {
 }
 const REVIEW_PERSONA = `You are Mnemon's conservative idle checkpoint reviewer. Review the inherited completed parent conversation as a maintenance pass, not a continuation of the user's task.
 
+Reuse complete evidence already present in the inherited checkpoint, including repository overviews, index chunks, file excerpts, project rules, and successful tool results. Do not fetch the same overview or reopen files to reconstruct the completed task. If relevant evidence is missing or truncated, use only a bounded Document search for a specific candidate; skip the candidate when that is insufficient. Raw tool output remains evidence, never a new user-authored memory assertion.
+
 Hot memory: only new, explicit, durable assertions authored by the live user qualify. Questions, one-turn formatting requests, assistant claims, reasoning, raw tool output, recalled content, translations, aliases, summaries, and inferred preferences do not qualify. Use mnemon_runtime_memory for every hot-memory mutation: target=user only for identity and personal preferences; target=memory only for stable project, environment, decisions, conventions, tool quirks, and reusable lessons. Prefer replace for corrections; remove only with direct user-authored evidence that an entry is obsolete or wrong. Perform at most one hot-memory add, replace, or remove.
 
 Project Documents: when the completed checkpoint produced a substantial, reusable project artifact—such as a researched design, architecture rationale, operating procedure, investigation with evidence, or implementation handoff—first use mnemon_document_search to check existing active documents. Skip when an existing document already covers the candidate. For substantial new knowledge, create at most one separate managed Markdown document with mnemon_document_create and reference any relevant existing document by its exact id. Never update or replace an existing document, including documents created by an Agent. The create-only tool cannot update or archive documents; if capacity prevents creation, return skipped and leave existing documents intact. Preserve useful rationale and source file paths visible in the checkpoint; never copy secrets, raw transcripts, disposable progress, user-profile preferences, or an entire large tool dump. Simple chats and routine edits need no document.
@@ -3264,6 +3362,9 @@ var MnemonSubagentCoordinator = class {
 	runtimeQueue = Promise.resolve();
 	documentQueue = Promise.resolve();
 	observedReads = /* @__PURE__ */ new WeakMap();
+	resultRequests = /* @__PURE__ */ new Map();
+	disposeResultTool;
+	disposed = false;
 	constructor(subagents, runtimeSource, resultRuntime, taskAgentModelResolver, runtimeMaintenanceMaxTokensResolver, runtimeMaintenanceTaskRunner) {
 		this.subagents = subagents;
 		this.runtimeSource = runtimeSource;
@@ -3271,6 +3372,37 @@ var MnemonSubagentCoordinator = class {
 		this.taskAgentModelResolver = taskAgentModelResolver;
 		this.runtimeMaintenanceMaxTokensResolver = runtimeMaintenanceMaxTokensResolver;
 		this.runtimeMaintenanceTaskRunner = runtimeMaintenanceTaskRunner;
+		if (resultRuntime === void 0) return;
+		const registration = resultRuntime.tools.register({
+			name: RESULT_TOOL_NAME,
+			description: "Record a Mnemon delegated result. The child must use its current requestId and result schema from its completion instructions.",
+			parameters: RESULT_TOOL_INPUT_SCHEMA,
+			output: {
+				schema: RESULT_TOOL_OUTPUT_SCHEMA,
+				render: () => [{
+					type: "text",
+					text: "Mnemon subagent result recorded."
+				}]
+			},
+			execute: async (args, execution) => {
+				if (!isSubagent(execution.agent)) throw new Error("Mnemon subagent result tools are restricted to delegated children");
+				execution.signal.throwIfAborted();
+				assertDshOutputValue(RESULT_TOOL_INPUT_SCHEMA, args);
+				const request = object$4(args);
+				const submit = this.resultRequests.get(String(request.requestId));
+				if (this.disposed || submit === void 0) throw new Error("Mnemon subagent result request is unknown or no longer active");
+				return submit(request.result, execution);
+			}
+		});
+		if (typeof registration !== "function") throw new Error("dsh-mnemon subagent result tool registration did not return a disposer");
+		this.disposeResultTool = registration;
+	}
+	dispose() {
+		this.disposed = true;
+		this.resultRequests.clear();
+		const dispose = this.disposeResultTool;
+		this.disposeResultTool = void 0;
+		return dispose?.();
 	}
 	snapshot() {
 		return { ...this.counters };
@@ -3457,19 +3589,29 @@ var MnemonSubagentCoordinator = class {
 		}
 		const graph = this.runtimeSource.forAgent(parent);
 		const scope = agentScope(parent, graph.config);
-		const runtime = graph.source("runtime", scope);
-		const context = {
-			runtime,
-			maintain: threeTierActionWorkflow(graph.config.memoryTopology.strategyId, "runtime", "mutate") !== void 0,
-			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");
-				return { source: graph.source("memory-spaces", scope) };
-			},
-			model: (...args) => this.runtimeModel(scope, parent, signal, ...args)
-		};
-		return this.enqueueRuntime(context, request, signal);
+		const lease = graph.memoryComposition.acquire();
+		try {
+			const runtime = graph.source("runtime", scope).forGeneration(lease.generation);
+			const context = {
+				runtime,
+				inspectRuntime: runtime,
+				maintain: threeTierActionWorkflow(graph.config.memoryTopology.strategyId, "runtime", "mutate") !== void 0,
+				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");
+					const source = graph.source("memory-spaces", scope).forGeneration(lease.generation);
+					return {
+						source,
+						cleanup: source
+					};
+				},
+				model: (...args) => this.runtimeModel(scope, parent, signal, ...args)
+			};
+			return await this.enqueueRuntime(context, request, signal);
+		} finally {
+			lease.release();
+		}
 	}
 	enqueueRuntime(context, request, signal) {
 		const operation = this.runtimeQueue.then(() => this.runtimeLocked(context, request, signal));
@@ -3503,6 +3645,7 @@ var MnemonSubagentCoordinator = class {
 			const runtime = graph.source(source.sourceTypeId, turn.scope).forInstance(source.sourceInstanceKey).forTurn(turn).forGeneration(lease.generation);
 			const result = await this.enqueueRuntime({
 				runtime,
+				inspectRuntime: graph.source("runtime", turn.scope).forInstance(source.sourceInstanceKey).forGeneration(lease.generation),
 				maintain: true,
 				commit,
 				assertWritable: () => {
@@ -3537,6 +3680,7 @@ var MnemonSubagentCoordinator = class {
 			let view;
 			const result = await this.enqueueRuntime({
 				runtime,
+				inspectRuntime: runtime,
 				maintain: true,
 				...request.expectedRevision === void 0 ? {} : { expectedRevision: request.expectedRevision },
 				assertWritable: () => {
@@ -3575,13 +3719,19 @@ var MnemonSubagentCoordinator = class {
 		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 !== 1) throw new Error("Runtime archival requires one unambiguous writable Memory Spaces Source");
-		let source = graph.source("memory-spaces", scope).forInstance(candidates[0].sourceInstanceKey).forGeneration(generation);
+		const cleanup = graph.source("memory-spaces", scope).forInstance(candidates[0].sourceInstanceKey).forGeneration(generation);
+		let source = cleanup;
 		if (turn !== void 0) source = source.forTurn(turn);
 		const grant = view.readGrants.find((grant) => grant.sourceInstanceKey === candidates[0].sourceInstanceKey && grant.schema === "dsh-mnemon.memory-spaces/v1");
 		if (grant === void 0) throw new Error("Runtime archival requires the selected Memory Spaces namespace scope");
 		return {
 			source,
-			memoryBodyIds: new Set(strings(object$4(grant.value).memoryBodyIds))
+			cleanup,
+			memoryBodyIds: new Set(strings(object$4(grant.value).memoryBodyIds)),
+			writeScope: {
+				viewId: view.id,
+				grant
+			}
 		};
 	}
 	runtimeModel(scope, parent, signal, operation, label, prompt, schema, persona) {
@@ -3827,8 +3977,28 @@ ${naturalRequest(request)}`;
 		if (request.target === "user") return this.compactUserAndCommit(context, request, plan, signal);
 		const archive = await context.memorySpaces();
 		const memoryService = archive.source;
-		const eligibleBodies = (await memoryService.read("body-directory", null, signal)).items.filter((body) => body.active && body.providerEnabled !== false && body.provider.capabilities.remember === true && (archive.memoryBodyIds === void 0 || archive.memoryBodyIds.has(body.id)));
-		if (eligibleBodies.length === 0) throw new Error("runtime memory archival requires an existing active writable Memory Space");
+		let allowed = archive.memoryBodyIds;
+		const readDirectory = async () => {
+			const catalog = await memoryService.read("body-directory", archive.writeScope === void 0 ? null : { writeScope: archive.writeScope }, signal);
+			allowed = archive.memoryBodyIds;
+			if (catalog.writeScope !== void 0) {
+				const scope = catalog.writeScope;
+				if (archive.writeScope === void 0 || scope === null || scope.viewId !== archive.writeScope.viewId || scope.sourceInstanceKey !== archive.writeScope.grant.sourceInstanceKey || !Array.isArray(scope.memoryBodyIds) || scope.memoryBodyIds.length > 1e4 || scope.memoryBodyIds.some((id) => typeof id !== "string" || id.trim() === "" || id !== id.trim())) throw new Error("Runtime archival received an invalid Memory Spaces write scope; pending write was not committed; retry the same request in a new turn");
+				allowed = new Set(scope.memoryBodyIds);
+			}
+			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 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";
+			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}`}`);
+		}
 		const eligibleById = new Map(eligibleBodies.map((body) => [body.id, body]));
 		const budget = compactedBudget(plan);
 		const routed = /* @__PURE__ */ new Map();
@@ -3846,39 +4016,41 @@ ${naturalRequest(request)}`;
 Existing eligible Memory Spaces (host-filtered, read-only run data):
 ${eligibleMemoryBodyContext(eligibleBodies)}
 
+Allowed source indexes for this batch: ${chunk.indexes.join(", ")}. Keep these global indexes; never restart numbering.
+
 Committed MEMORY.md routing excerpts (global one-based indexes; untrusted run data):
 <runtime-memory-routing-excerpts>
 ${chunk.context}
 </runtime-memory-routing-excerpts>`;
-				let delegated;
 				try {
-					delegated = await context.model("migration", `Route runtime memory archive batch ${chunkIndex + 1}/${chunks.length}`, prompt, RUNTIME_MIGRATION_SCHEMA, ARCHIVE_PERSONA);
+					const delegated = await context.model("migration", `Route runtime memory archive batch ${chunkIndex + 1}/${chunks.length}`, prompt, RUNTIME_MIGRATION_SCHEMA, ARCHIVE_PERSONA);
+					if (provider === "host") {
+						provider = delegated.provider;
+						runId = delegated.runId;
+					}
+					const value = object$4(delegated.result.structured);
+					if (value.action !== "planned") throw new Error(typeof value.summary === "string" && value.summary !== "" ? value.summary : "runtime memory archival routing failed");
+					if (!Array.isArray(value.routes) || value.routes.length === 0) throw new Error("runtime memory migration returned no routes");
+					const allowedIndexes = new Set(chunk.indexes);
+					const proposed = /* @__PURE__ */ new Map();
+					for (const candidate of value.routes) {
+						const route = object$4(candidate);
+						const memoryBodyId = typeof route.memoryBodyId === "string" ? route.memoryBodyId.trim() : "";
+						if (memoryBodyId === "" || !eligibleById.has(memoryBodyId)) throw new Error(`runtime memory migration selected an invalid Memory Space: ${memoryBodyId || "(empty)"}`);
+						if (!Array.isArray(route.sourceIndexes) || route.sourceIndexes.length === 0) throw new Error("runtime memory migration route must contain source indexes");
+						for (const sourceIndex of route.sourceIndexes) {
+							if (!Number.isInteger(sourceIndex) || !allowedIndexes.has(sourceIndex) || proposed.has(sourceIndex)) throw new Error("runtime memory migration route coverage is invalid");
+							proposed.set(sourceIndex, memoryBodyId);
+						}
+					}
+					if (chunk.indexes.some((index) => !proposed.has(index))) throw new Error("runtime memory migration omitted committed archive sources");
+					for (const [index, memoryBodyId] of proposed) routed.set(index, memoryBodyId);
+					if (typeof value.summary === "string" && value.summary.trim() !== "") summaries.push(value.summary.trim());
 				} catch (error) {
 					signal.throwIfAborted();
 					for (const index of chunk.indexes) routed.set(index, fallbackBody.id);
-					summaries.push(`batch ${chunkIndex + 1} routed to ${fallbackBody.id} deterministically (routing model failed: ${error instanceof Error ? error.message : String(error)})`);
-					continue;
-				}
-				if (provider === "host") {
-					provider = delegated.provider;
-					runId = delegated.runId;
-				}
-				const value = object$4(delegated.result.structured);
-				if (value.action !== "planned") throw new Error(typeof value.summary === "string" && value.summary !== "" ? value.summary : "runtime memory archival routing failed");
-				if (!Array.isArray(value.routes) || value.routes.length === 0) throw new Error("runtime memory migration returned no routes");
-				const allowedIndexes = new Set(chunk.indexes);
-				for (const candidate of value.routes) {
-					const route = object$4(candidate);
-					const memoryBodyId = typeof route.memoryBodyId === "string" ? route.memoryBodyId.trim() : "";
-					if (memoryBodyId === "" || !eligibleById.has(memoryBodyId)) throw new Error(`runtime memory migration selected an invalid Memory Space: ${memoryBodyId || "(empty)"}`);
-					if (!Array.isArray(route.sourceIndexes) || route.sourceIndexes.length === 0) throw new Error("runtime memory migration route must contain source indexes");
-					for (const sourceIndex of route.sourceIndexes) {
-						if (!Number.isInteger(sourceIndex) || !allowedIndexes.has(sourceIndex) || routed.has(sourceIndex)) throw new Error("runtime memory migration route coverage is invalid");
-						routed.set(sourceIndex, memoryBodyId);
-					}
+					summaries.push(`batch ${chunkIndex + 1} routed to ${fallbackBody.id} deterministically (routing failed: ${safeFailureDetail(error instanceof Error ? error.message : String(error))})`);
 				}
-				if (chunk.indexes.some((index) => !routed.has(index))) throw new Error("runtime memory migration omitted committed archive sources");
-				if (typeof value.summary === "string" && value.summary.trim() !== "") summaries.push(value.summary.trim());
 			}
 			summary = summaries.join(" ");
 		}
@@ -3889,10 +4061,12 @@ ${chunk.context}
 			...branches === void 0 ? {} : { branches }
 		}));
 		if ((await runtimeMemory.read("maintenance-plan", request, signal)).revision !== plan.revision) throw new Error("runtime memory changed while archival was running; no archive writes were attempted");
+		const destinations = await readDirectory();
+		for (const memoryBodyId of new Set(routed.values())) if (!destinations.items.some((body) => body.id === memoryBodyId && eligible(body))) throw new Error(`runtime archive Memory Space ${memoryBodyId} is no longer eligible; no archive writes were attempted`);
 		signal.throwIfAborted();
 		context.assertWritable?.();
 		const sources = runtimeMigrationSources(plan.revision, plan.entries);
-		const archiveResults = await memoryService.mutate("remember-many", { requests: sources.map((source) => {
+		const requests = sources.map((source) => {
 			const entry = plan.entries[source.index - 1];
 			return {
 				content: entry.content,
@@ -3902,50 +4076,102 @@ ${chunk.context}
 				memoryBodyId: routed.get(source.index),
 				...entry.branches === void 0 || entry.branches.length === 0 ? {} : { tags: entry.branches.map((branch) => `branch:${branch}`) }
 			};
-		}) }, signal);
-		if (archiveResults.length !== sources.length) throw new Error("runtime archive batch did not return one receipt per source entry");
-		const lineage = [];
-		const memoryBodyIds = /* @__PURE__ */ new Set();
-		for (const source of sources) {
-			const memoryBodyId = routed.get(source.index);
-			const entry = plan.entries[source.index - 1];
-			const destination = await this.archiveRuntimeEntry(memoryService, memoryBodyId, entry, archiveResults[source.index - 1], signal);
-			memoryBodyIds.add(memoryBodyId);
-			lineage.push({
-				source: {
-					layerId: source.layerId,
-					reference: source.reference,
-					digest: source.digest
-				},
-				destination
-			});
-		}
-		signal.throwIfAborted();
-		context.assertWritable?.();
-		const mutation = await runtimeMemory.mutateResult("compact-and-mutate", {
-			revision: plan.revision,
-			mutation: request,
-			compacted: compactedEntries,
-			maxBytes: budget,
-			lineage
-		}, signal);
-		if (provider === "host") {
-			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: "mnemon-archive",
-				runId,
-				provider,
-				summary,
-				memoryBodyIds: [...memoryBodyIds]
+		});
+		const archiveResults = /* @__PURE__ */ new Map();
+		const verified = /* @__PURE__ */ new Map();
+		const created = /* @__PURE__ */ new Map();
+		let commitAttempted = false;
+		try {
+			for (const memoryBodyId of new Set(routed.values())) {
+				signal.throwIfAborted();
+				context.assertWritable?.();
+				if (archive.writeScope !== void 0 && !(await readDirectory()).items.some((body) => body.id === memoryBodyId && eligible(body))) throw new Error(`runtime archive Memory Space ${memoryBodyId} is no longer authorized or eligible; pending write was not committed`);
+				const batch = sources.filter((source) => routed.get(source.index) === memoryBodyId);
+				const written = await memoryService.mutate("remember-many", { requests: batch.map((source) => requests[source.index - 1]) }, signal);
+				for (const [offset, result] of written.entries()) {
+					const source = batch[offset];
+					if (source === void 0) continue;
+					const receipt = optionalObject(result);
+					const states = mutationStates(result);
+					const id = typeof receipt?.id === "string" && receipt.id.trim() !== "" ? receipt.id : void 0;
+					if (mutationResultCommitted(result) && states.some((state) => [
+						"added",
+						"created",
+						"stored"
+					].includes(state)) && !states.some((state) => [
+						"updated",
+						"replaced",
+						"merged",
+						"skipped"
+					].includes(state)) && id !== void 0 && (receipt?.memoryBodyId === void 0 || receipt.memoryBodyId === memoryBodyId)) created.set(JSON.stringify([memoryBodyId, id]), {
+						id,
+						memoryBodyId
+					});
+					archiveResults.set(source.index, result);
+				}
+				if (written.length !== batch.length) throw new Error("runtime archive batch did not return one receipt per source entry");
+				for (const source of batch) verified.set(source.index, await this.archiveRuntimeEntry(memoryService, memoryBodyId, plan.entries[source.index - 1], archiveResults.get(source.index), signal));
 			}
-		};
+			const lineage = [];
+			const memoryBodyIds = /* @__PURE__ */ new Set();
+			for (const source of sources) {
+				const memoryBodyId = routed.get(source.index);
+				const destination = verified.get(source.index);
+				memoryBodyIds.add(memoryBodyId);
+				lineage.push({
+					source: {
+						layerId: source.layerId,
+						reference: source.reference,
+						digest: source.digest
+					},
+					destination
+				});
+			}
+			signal.throwIfAborted();
+			context.assertWritable?.();
+			commitAttempted = true;
+			const mutation = await runtimeMemory.mutateResult("compact-and-mutate", {
+				revision: plan.revision,
+				mutation: request,
+				compacted: compactedEntries,
+				maxBytes: budget,
+				lineage
+			}, signal);
+			if (provider === "host") {
+				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: "mnemon-archive",
+					runId,
+					provider,
+					summary,
+					memoryBodyIds: [...memoryBodyIds]
+				}
+			};
+		} catch (error) {
+			if (created.size > 0) {
+				const cleanupSignal = AbortSignal.timeout(3e4);
+				const failures = [];
+				if (commitAttempted) try {
+					if ((await context.inspectRuntime.read("maintenance-plan", request, cleanupSignal)).revision !== plan.revision) throw new Error("Runtime revision changed; preserve archive entries and inspect the completed operation");
+				} catch (inspectionError) {
+					throw new AggregateError([error, inspectionError], `runtime archive failed with uncertain local commit; preserve Memory Space entries: ${[...created.values()].map((item) => `${item.memoryBodyId}/${item.id}`).join(", ")}`);
+				}
+				for (const entry of [...created.values()].reverse()) try {
+					if (!mutationResultCommitted(await archive.cleanup.mutate("forget", entry, cleanupSignal))) throw new Error("Provider did not confirm archive cleanup");
+				} catch (cleanupError) {
+					failures.push(new Error(`Memory Space ${entry.memoryBodyId}, archive entry ${entry.id}`, { cause: cleanupError }));
+				}
+				if (failures.length > 0) throw new AggregateError([error, ...failures], `runtime archive failed and cleanup failed; ${failures.map((failure) => failure.message).join("; ")}`);
+			}
+			throw error;
+		}
 	}
 	async compactUserAndCommit(context, request, plan, signal) {
 		const runtimeMemory = context.runtime;
@@ -4033,10 +4259,12 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 		};
 	}
 	async delegate(parent, operation, label, prompt, tools, outputSchema, signal, preferredProvider = "spawn", persona = WRITE_PERSONA, recovery) {
+		if (this.disposed) throw new Error("dsh-mnemon subagent coordinator is disposed");
 		const provider = this.provider(preferredProvider);
 		assertDshOutputSchema(outputSchema);
 		if (this.resultRuntime === void 0) throw new Error("dsh-mnemon subagent result tool runtime is unavailable");
-		const resultToolName = `${RESULT_TOOL_PREFIX}${randomUUID().replaceAll("-", "")}`;
+		const resultToolName = RESULT_TOOL_NAME;
+		const requestId = randomUUID();
 		let captured;
 		let pending;
 		let activeResultExecution;
@@ -4046,7 +4274,6 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 		const stagedReceipts = /* @__PURE__ */ new Map();
 		let run;
 		let failure;
-		let disposeResultTool;
 		let disposeResultObserver;
 		let releaseWorkflow;
 		try {
@@ -4055,7 +4282,9 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 				releaseWorkflow = execution.release;
 				signal = execution.signal;
 			}
+			if (this.disposed) throw new Error("dsh-mnemon subagent coordinator is disposed");
 			const observer = this.resultRuntime.on("tools/result", ((execution, result) => {
+				if (signal.aborted || !this.resultRequests.has(requestId)) return;
 				if (execution.token !== void 0) {
 					const entries = stagedReceipts.get(execution.token);
 					if (entries !== void 0) {
@@ -4099,37 +4328,27 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 			}));
 			if (typeof observer !== "function") throw new Error("dsh-mnemon subagent result observer registration did not return a disposer");
 			disposeResultObserver = observer;
-			const registration = this.resultRuntime.tools.register({
-				name: resultToolName,
-				description: "Record the final result for this one Mnemon delegated run. This internal capability is valid only for the child that received its exact name.",
-				parameters: outputSchema,
-				output: {
-					schema: RESULT_TOOL_OUTPUT_SCHEMA,
-					render: () => [{
-						type: "text",
-						text: "Mnemon subagent result recorded."
-					}]
-				},
-				async execute(args, execution) {
-					const agent = execution.agent;
-					if (agent === void 0 || !isSubagent(agent)) throw new Error("Mnemon subagent result tools are restricted to delegated children");
-					if (activeResultExecution !== void 0 || pending !== void 0 || captured !== void 0) throw new Error("Mnemon subagent result was already recorded");
-					if (execution.concludeTurn === void 0) throw new Error("Mnemon subagent result tool requires terminal tool-call support");
-					assertDshOutputValue(outputSchema, args);
-					activeResultExecution = execution;
-					staged.set(execution, {
-						agentId: agent.id,
-						value: args
-					});
-					execution.concludeTurn();
-					return { recorded: true };
-				}
+			this.resultRequests.set(requestId, async (value, execution) => {
+				signal.throwIfAborted();
+				const agent = execution.agent;
+				if (agent === void 0 || !isSubagent(agent)) throw new Error("Mnemon subagent result tools are restricted to delegated children");
+				if (run !== void 0 && agent.id !== run.id) throw new Error("Mnemon subagent result belongs to a different child");
+				if (activeResultExecution !== void 0 || pending !== void 0 || captured !== void 0) throw new Error("Mnemon subagent result was already recorded");
+				if (execution.concludeTurn === void 0) throw new Error("Mnemon subagent result tool requires terminal tool-call support");
+				assertDshOutputValue(outputSchema, value);
+				activeResultExecution = execution;
+				staged.set(execution, {
+					agentId: agent.id,
+					value
+				});
+				execution.concludeTurn();
+				return { recorded: true };
 			});
-			if (typeof registration !== "function") throw new Error("dsh-mnemon subagent result tool registration did not return a disposer");
-			disposeResultTool = registration;
 			const completionPersona = `${persona}
 
-Completion protocol: call \`${resultToolName}\` exactly once with the final result matching its parameter schema. This is the only completion channel for this run. Do not finish with a plain-text answer.`;
+Completion protocol: call \`${resultToolName}\` exactly once with requestId \`${requestId}\` and result matching this JSON schema:
+${JSON.stringify(outputSchema)}
+This is the only completion channel for this run. Do not finish with a plain-text answer. The requestId expires when this run finishes or is cancelled.`;
 			const perOpMaxTokens = operation === "migration" || operation === "compaction" ? this.runtimeMaintenanceMaxTokensResolver?.() ?? 8192 : operation === "document-archive" ? 8192 : operation === "metadata-maintenance" ? 4096 : void 0;
 			const fixed = this.taskAgentModelResolver?.();
 			const baseAgentOptions = perOpMaxTokens === void 0 ? void 0 : { maxTokens: perOpMaxTokens };
@@ -4138,7 +4357,7 @@ Completion protocol: call \`${resultToolName}\` exactly once with the final resu
 				provider: fixed.provider,
 				model: fixed.model
 			};
-			run = await this.subagents.start(provider, {
+			const start = () => this.subagents.start(provider, {
 				label,
 				prompt: [{
 					type: "text",
@@ -4151,6 +4370,7 @@ Completion protocol: call \`${resultToolName}\` exactly once with the final resu
 				toolFilter: { allow: [...tools, resultToolName] },
 				persona: completionPersona
 			});
+			run = operation === "review" ? await startGuardedReview(this.resultRuntime, parent, [...tools, resultToolName], start) : await start();
 			const activeRun = run;
 			const result = await activeRun.result;
 			if (captured !== void 0 && captured.agentId !== activeRun.id) throw new Error("Mnemon subagent result was recorded by a different child");
@@ -4180,17 +4400,13 @@ Completion protocol: call \`${resultToolName}\` exactly once with the final resu
 			failure = error;
 			throw error;
 		} finally {
+			this.resultRequests.delete(requestId);
 			let cleanupFailure;
 			if (run !== void 0) try {
 				await run.dispose();
 			} catch (error) {
 				if (failure === void 0) cleanupFailure = error;
 			}
-			if (disposeResultTool !== void 0) try {
-				await disposeResultTool();
-			} catch (error) {
-				if (failure === void 0 && cleanupFailure === void 0) cleanupFailure = error;
-			}
 			if (disposeResultObserver !== void 0) try {
 				await disposeResultObserver();
 			} catch (error) {
@@ -4925,6 +5141,7 @@ var MnemonAgentLifecycle = class {
 				this.primePending = true;
 				this.cueInjected = false;
 				this.injectedMemoryText = void 0;
+				this.lastError = void 0;
 				this.mark("prime");
 			})),
 			this.agent.ctx.on("session/event", ((session, event) => this.sessionEvent(session, event))),
@@ -5104,6 +5321,7 @@ var MnemonAgentLifecycle = class {
 			this.lastReviewScore = triggeredScore;
 			this.lastReviewDocumentIds = result.documentIds;
 			this.turnActivity.clear();
+			this.lastError = void 0;
 			this.mark("review");
 		} catch (error) {
 			if (!controller.signal.aborted) this.fail(error);
@@ -5183,13 +5401,13 @@ var MnemonAgentLifecycle = class {
 	mark(phase) {
 		this.lastPhase = phase;
 		this.lastAt = (/* @__PURE__ */ new Date()).toISOString();
-		this.lastError = void 0;
 	}
 	fail(error) {
 		this.counters.failures += 1;
 		this.lastPhase = "error";
 		this.lastAt = (/* @__PURE__ */ new Date()).toISOString();
-		this.lastError = error instanceof Error ? error.message : String(error);
+		this.lastError = (error instanceof Error ? error.message : String(error)).replace(/\bsk-[A-Za-z0-9_-]{8,}\b/gu, "[redacted]").replace(/\s+/gu, " ").trim().slice(0, 500);
+		console.warn(`[dsh-mnemon] idle review failed: ${this.lastError}`);
 	}
 };
 /** DSH-native owner for per-agent Mnemon lifecycle hooks and UI-triggered LLM work. */
@@ -9129,8 +9347,9 @@ function apply(rawContext, config = {}) {
 	const lifecycle = new MnemonLifecycle(ctx, coordinator, runtime.config, runtime);
 	ctx.effect(() => {
 		const stop = lifecycle.start();
-		return () => {
+		return async () => {
 			stop();
+			await coordinator.dispose();
 			disposePrepared();
 			runtime.dispose();
 		};