dsh-mnemon 0.5.37 → 0.5.38

package/lib/index.js

@@ -1,5 +1,5 @@
 import { f as canonicalWorkspacePath, m as withMemoryStorageLock, n as memoryStrategyConfigurationValues, p as workspaceStorageId, r as readMemoryStrategyConfiguration, s as receipt } from "./strategy-configuration-CKP2kRss.js";
-import { a as validateMemoryPluginGraph, i as captureMemoryContributionSnapshot, n as isMemoryCompositionUnavailable, o as prepareMemoryContributions, r as MemoryCompositionGeneration, t as provideMemoryRuntime } from "./runtime-zuuBe8x1.js";
+import { a as validateMemoryPluginGraph, i as captureMemoryContributionSnapshot, n as isMemoryCompositionUnavailable, o as prepareMemoryContributions, r as MemoryCompositionGeneration, t as provideMemoryRuntime } from "./runtime-0u6dOiF9.js";
 import { DEFAULT_MEMORY_VIEW_BUDGET, MEMORY_CAPABILITIES } from "./contracts.js";
 import { r as defineMemoryPlugin, t as canonicalMemoryJson } from "./definitions-DU7MLBhu.js";
 import { Context } from "@deepseek-ai/cordis";
@@ -9,7 +9,7 @@ import { resolveEmbedding, resolvePersistenceStrategy, resolveRecallQuality } fr
 import { CATEGORIES, DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, EDGE_TYPES, MEMORY_PLACEMENT_CAPABILITIES, MEMORY_PROVIDER_REGISTRY_FILE, MEMORY_SPACES_DIRECTORY, MEMORY_SPACE_DATABASE_FILE, MEMORY_SPACE_ID_PATTERN, MEMORY_SPACE_NAME_MAX_LENGTH, MEMORY_SPACE_REGISTRY_FILE, MNEMON_ACTIVE_STORE_FILE, MNEMON_EMBEDDING_PROTOCOLS, SOURCES, parseMemorySpaceRegistry, summarizeMemoryProviderRegistry, summarizeMemorySpaceRegistry } from "dsh-mnemon-source-memory-spaces/contracts";
 import { RUNTIME_ARCHIVE_DIRECTORY, RUNTIME_DIRECTORY, RUNTIME_ENTRY_DELIMITER, RUNTIME_ENTRY_MAX_BYTES, RUNTIME_LOCK_FILE, RUNTIME_LOCK_STALE_MS, RUNTIME_MEMORIES_FILE, RUNTIME_MEMORY_LIMITS, RUNTIME_MEMORY_LIMIT_MAX_BYTES, RUNTIME_MEMORY_VERSION, RUNTIME_PROJECTION_FILES, parseRuntimeBranches, runtimeBytes, runtimeProjection, summarizeRuntimeMemories } from "dsh-mnemon-source-runtime/contracts";
 import { createHash, randomUUID } from "node:crypto";
-import { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import fs, { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { strToU8, unzipSync, zipSync } from "fflate";
 import { DOCUMENTS_ACTIVE_LIMIT_BYTES, DOCUMENTS_DIRECTORY, DOCUMENTS_INDEX_FILE, DOCUMENTS_LOCK_FILE, DOCUMENTS_LOCK_STALE_MS, DOCUMENT_FILENAME_PATTERN, parseDocumentIndex, summarizeDocumentIndex } from "dsh-mnemon-source-documents/contracts";
@@ -374,6 +374,7 @@ function isWorkspaceStorageScope(scope) {
 const DEFAULT_IDLE_REVIEW = {
 	enabled: true,
 	runtimeMemory: true,
+	persistWatermark: false,
 	provider: "spawn",
 	fallback: "spawn",
 	agentTeams: "pause",
@@ -535,6 +536,7 @@ const RuntimeMemorySchema = z.object({
 const IdleReviewSchema = z.object({
 	enabled: z.boolean().default(DEFAULT_IDLE_REVIEW.enabled),
 	runtimeMemory: z.boolean().default(DEFAULT_IDLE_REVIEW.runtimeMemory),
+	persistWatermark: z.boolean().default(DEFAULT_IDLE_REVIEW.persistWatermark),
 	provider: z.union(["spawn", "fork"]).default(DEFAULT_IDLE_REVIEW.provider),
 	fallback: z.union(["spawn", "skip"]).default(DEFAULT_IDLE_REVIEW.fallback),
 	agentTeams: z.union(["pause", "scoped"]).default(DEFAULT_IDLE_REVIEW.agentTeams),
@@ -1257,7 +1259,7 @@ const LOADED_VERSION = manifest$1(PACKAGE_MANIFEST_PATH)?.version;
 function pluginPackageVersion() {
 	return LOADED_VERSION ?? "0.0.0";
 }
-const CHECK_TIMEOUT_MS = 1e4;
+const CHECK_TIMEOUT_MS$1 = 1e4;
 const UPDATE_TIMEOUT_MS = 6e5;
 /** A check waits this long for an update that is finishing, within the browser's 15 s check deadline. */
 const IN_FLIGHT_WAIT_MS = 3e3;
@@ -1353,7 +1355,7 @@ async function fetchJson(url) {
 	const controller = new AbortController();
 	const timeout = setTimeout(() => {
 		controller.abort();
-	}, CHECK_TIMEOUT_MS);
+	}, CHECK_TIMEOUT_MS$1);
 	try {
 		const response = await fetch(url, {
 			signal: controller.signal,
@@ -1621,7 +1623,7 @@ var VersionUpdateManager = class {
 		let current;
 		try {
 			const invocation = resolveMnemonInvocation(command, ["--version"]);
-			current = versionFrom((await resultOrThrow(this.processRunner, invocation.command, invocation.args, CHECK_TIMEOUT_MS, { env: invocation.env })).stdout);
+			current = versionFrom((await resultOrThrow(this.processRunner, invocation.command, invocation.args, CHECK_TIMEOUT_MS$1, { env: invocation.env })).stdout);
 		} catch {
 			return { install: {
 				mode: launcher === void 0 ? "manual" : "npm",
@@ -1642,7 +1644,7 @@ var VersionUpdateManager = class {
 					...npm.args,
 					"root",
 					"--global"
-				], CHECK_TIMEOUT_MS, { env: npm.env })).stdout.trim();
+				], CHECK_TIMEOUT_MS$1, { env: npm.env })).stdout.trim();
 				if (isAbsolute(globalRoot) && samePath(dirname(dirname(launcher)), join(globalRoot, MNEMON_NPM_PACKAGE))) {
 					install.hint = "npm";
 					install.updateCommand = process.execPath;
@@ -1703,7 +1705,7 @@ var VersionUpdateManager = class {
 				"GOARCH",
 				"GOHOSTOS",
 				"GOHOSTARCH"
-			], CHECK_TIMEOUT_MS)).stdout);
+			], CHECK_TIMEOUT_MS$1)).stdout);
 			const goPath = typeof environment.GOPATH === "string" ? environment.GOPATH.split(delimiter)[0] : void 0;
 			const bin = typeof environment.GOBIN === "string" && environment.GOBIN !== "" ? environment.GOBIN : goPath === void 0 || goPath === "" ? void 0 : join(goPath, "bin");
 			if (bin === void 0 || !isAbsolute(bin) || typeof environment.GOOS !== "string" || environment.GOOS !== environment.GOHOSTOS || typeof environment.GOARCH !== "string" || environment.GOARCH !== environment.GOHOSTARCH || realpathSync(join(bin, process.platform === "win32" ? "mnemon.exe" : "mnemon")) !== realCommand) return {
@@ -1717,7 +1719,7 @@ var VersionUpdateManager = class {
 				"version",
 				"-m",
 				command
-			], CHECK_TIMEOUT_MS)).stdout.split(/\r?\n/).map((line) => line.trim().split(/\s+/)).find((fields) => fields[0] === "path")?.[1] === MNEMON_MODULE) return {
+			], CHECK_TIMEOUT_MS$1)).stdout.split(/\r?\n/).map((line) => line.trim().split(/\s+/)).find((fields) => fields[0] === "path")?.[1] === MNEMON_MODULE) return {
 				...current === void 0 ? {} : { current },
 				install: {
 					mode: "go",
@@ -3994,7 +3996,7 @@ function shapeOf(answer) {
 	const listed = keys.length > names.length ? [...names, String(keys.length - names.length) + " other"] : names;
 	return "HTTP " + String(answer.status) + ", content-type " + (answer.type ?? "none") + ", fields: " + (listed.length === 0 ? "none" : listed.join(", "));
 }
-function failure$2(action, status, body) {
+function failure$3(action, status, body) {
 	const code = codeOf(body);
 	const message = code === void 0 ? action + " failed with HTTP " + String(status) : action + " failed: " + code;
 	return status === 401 ? new MnemonSyncError("github-unauthorized", message) : new Error(message);
@@ -4135,7 +4137,7 @@ var MnemonGitHubAuth = class {
 		} catch (error) {
 			throw new Error("the GitHub device code request could not reach GitHub: " + describeTransportError(error));
 		}
-		if (answer.status !== 200) throw failure$2("the GitHub device code request", answer.status, answer.body);
+		if (answer.status !== 200) throw failure$3("the GitHub device code request", answer.status, answer.body);
 		const fields = record$6(answer.body);
 		const deviceCode = text$1(fields?.device_code);
 		const userCode = text$1(fields?.user_code);
@@ -4283,7 +4285,7 @@ var MnemonGitHubAuth = class {
 				headers: this.authorization(token),
 				...signal === void 0 ? {} : { signal }
 			}, "listing GitHub repositories");
-			if (status !== 200) throw failure$2("listing GitHub repositories", status, body);
+			if (status !== 200) throw failure$3("listing GitHub repositories", status, body);
 			if (!Array.isArray(body)) throw new Error("the GitHub repository answer was not a list");
 			for (const entry of body) {
 				const repository = repositoryOf(entry);
@@ -4314,7 +4316,7 @@ var MnemonGitHubAuth = class {
 			}),
 			...signal === void 0 ? {} : { signal }
 		}, "creating the GitHub repository");
-		if (status !== 201) throw failure$2("creating the GitHub repository", status, body);
+		if (status !== 201) throw failure$3("creating the GitHub repository", status, body);
 		const repository = repositoryOf(body);
 		if (repository === void 0) throw new Error("the created GitHub repository could not be read back");
 		return repository;
@@ -7490,6 +7492,7 @@ var LiveMnemonRuntime = class {
 	githubAuth;
 	autoBackupView;
 	closed = false;
+	changeListeners = /* @__PURE__ */ new Set();
 	config;
 	storage;
 	packs;
@@ -7531,6 +7534,12 @@ var LiveMnemonRuntime = class {
 	applyAutoBackup(graph) {
 		if (this.autoBackupView !== void 0) graph.sync.useAutoBackup(this.autoBackupView);
 	}
+	onChanged(listener) {
+		this.changeListeners.add(listener);
+		return () => {
+			this.changeListeners.delete(listener);
+		};
+	}
 	swap(next) {
 		if (this.closed) {
 			next.dispose();
@@ -7544,6 +7553,7 @@ var LiveMnemonRuntime = class {
 		this.retireGraph(previous);
 		for (const graph of this.workspaceGraphs.values()) this.retireGraph(graph);
 		this.workspaceGraphs.clear();
+		for (const listener of this.changeListeners) listener();
 	}
 	snapshot() {
 		this.assertOpen();
@@ -7568,6 +7578,7 @@ var LiveMnemonRuntime = class {
 	dispose() {
 		if (this.closed) return;
 		this.executions.dispose();
+		this.changeListeners.clear();
 		this.closed = true;
 		const graphs = /* @__PURE__ */ new Set([
 			this.current,
@@ -10158,6 +10169,108 @@ async function assertAutomaticMemoryWrite(host, parent) {
 	return host.writableSourceFor(parent, "memory-spaces", "remember");
 }
 //#endregion
+//#region src/host/review-admission.ts
+const RESULT_TOOL = "mnemon_subagent_result";
+const CHECK_TIMEOUT_MS = 5e3;
+/** A no-op challenge through the same mandatory completion channel as review.
+* Inventory alone cannot see execution-time guards. No errors are classified as
+* permission failures, and an unavailable checkpoint is never a permanent ban.
+*/
+var AutomaticReviewAdmission = class {
+	challenges = /* @__PURE__ */ new Map();
+	controllers = /* @__PURE__ */ new Set();
+	draining = /* @__PURE__ */ new WeakSet();
+	disposed = false;
+	/** Only an unexpired, host-issued challenge for this exact Agent can no-op. */
+	acknowledge(args, execution) {
+		if (typeof args !== "object" || args === null || !("requestId" in args) || typeof args.requestId !== "string") return false;
+		const challenge = this.challenges.get(args.requestId);
+		if (challenge === void 0 || challenge.agent !== execution.agent || challenge.execution !== void 0) return false;
+		execution.signal.throwIfAborted();
+		challenge.execution = execution;
+		return true;
+	}
+	dispose() {
+		this.disposed = true;
+		this.challenges.clear();
+		for (const controller of this.controllers) controller.abort();
+	}
+	async check(agent, signal) {
+		signal.throwIfAborted();
+		const tools = agent.ctx.tools;
+		if (this.disposed || tools?.execute === void 0 || this.draining.has(agent)) return false;
+		const controller = new AbortController();
+		this.controllers.add(controller);
+		const combined = AbortSignal.any([signal, controller.signal]);
+		const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
+		timeout.unref?.();
+		let rejectAbort;
+		const aborted = new Promise((_resolve, reject) => {
+			rejectAbort = () => reject(combined.reason);
+			combined.addEventListener("abort", rejectAbort, { once: true });
+		});
+		const attempt = async (codeMode) => {
+			combined.throwIfAborted();
+			const requestId = randomUUID();
+			const callId = randomUUID();
+			const challenge = {
+				agent,
+				accepted: false
+			};
+			this.challenges.set(requestId, challenge);
+			const stops = [];
+			let executing = false;
+			const cleanup = () => {
+				for (const stop of stops.reverse()) stop();
+				this.draining.delete(agent);
+			};
+			try {
+				stops.push(agent.ctx.on("tools/result", ((execution, result) => {
+					if (execution === challenge.execution) challenge.accepted = result.isError === false;
+				})));
+				stops.push(agent.ctx.on("tools/pre-execute", (async (execution, next) => {
+					const decision = await next();
+					return execution.agent === agent && (execution.callId === callId || execution.rootCallId === callId) && decision.kind === "ask" ? { kind: "cancel" } : decision;
+				}), { prepend: true }));
+				const args = {
+					requestId,
+					result: {}
+				};
+				const pending = tools.execute({
+					callId,
+					agent,
+					signal: combined,
+					name: codeMode ? "run_code" : RESULT_TOOL,
+					arguments: codeMode ? {
+						description: "Check automatic memory review availability",
+						code: `await tools.mnemon_subagent_result(${JSON.stringify(args)})`
+					} : args
+				});
+				executing = true;
+				this.draining.add(agent);
+				const settled = pending.finally(cleanup);
+				const outcome = await Promise.race([settled, aborted]);
+				combined.throwIfAborted();
+				return challenge.execution !== void 0 && challenge.accepted && outcome.isError === false;
+			} finally {
+				this.challenges.delete(requestId);
+				if (!executing) cleanup();
+			}
+		};
+		try {
+			if (await attempt(false)) return true;
+			return tools.get?.("run_code", agent) !== void 0 && await attempt(true);
+		} catch {
+			signal.throwIfAborted();
+			return false;
+		} finally {
+			clearTimeout(timeout);
+			if (rejectAbort !== void 0) combined.removeEventListener("abort", rejectAbort);
+			this.controllers.delete(controller);
+		}
+	}
+};
+//#endregion
 //#region src/host/subagent.ts
 function evidenceInsights(evidence) {
 	return evidence.items.map((item) => {
@@ -10343,6 +10456,7 @@ var MnemonSubagentCoordinator = class {
 	/** Delegated children whose run has ended, newest last, at most FINISHED_CHILDREN. */
 	finishedChildren = /* @__PURE__ */ new Set();
 	disposed = false;
+	reviewAdmission = new AutomaticReviewAdmission();
 	constructor(subagents, runtimeSource, resultRuntime, taskAgentModelResolver, runtimeMaintenanceMaxTokensResolver, runtimeMaintenanceTaskRunner) {
 		this.subagents = subagents;
 		this.runtimeSource = runtimeSource;
@@ -10363,6 +10477,7 @@ var MnemonSubagentCoordinator = class {
 				}]
 			},
 			execute: async (args, execution) => {
+				if (this.reviewAdmission.acknowledge(args, execution)) return { recorded: true };
 				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);
@@ -10377,6 +10492,7 @@ var MnemonSubagentCoordinator = class {
 	}
 	dispose() {
 		this.disposed = true;
+		this.reviewAdmission.dispose();
 		this.resultRequests.clear();
 		const resumeGuard = this.disposeResumeGuard;
 		this.disposeResumeGuard = void 0;
@@ -10922,7 +11038,28 @@ ${naturalRequest(request, target === void 0 ? REQUEST_LABELS : TARGETED_WRITE_LA
 			throw new Error("The Memory Space directory could not be read, so nothing was saved: " + (error instanceof Error ? error.message : String(error)), { cause: error });
 		}
 	}
-	async review(parent, signal) {
+	/** Cheap scheduler admission: no model task when every review write target is unavailable. */
+	canReview(parent) {
+		return this.reviewTools(parent).some((tool) => tool !== "mnemon_document_search");
+	}
+	/** Automatic review admission; explicit user-requested reviews are unchanged. */
+	checkReviewAccess(parent, signal) {
+		return this.reviewAdmission.check(parent, signal);
+	}
+	availableTools(parent, tools) {
+		const registry = parent.ctx?.tools;
+		return typeof registry?.get === "function" ? tools.filter((name) => registry.get(name, parent) !== void 0) : [...tools];
+	}
+	reviewTools(parent) {
+		const config = this.runtimeSource.config;
+		if (!config.writeEnabled) return [];
+		return this.availableTools(parent, REVIEW_TOOLS).filter((tool) => {
+			if (tool === "mnemon_document_search") return true;
+			const type = memoryTool(tool).sourceTypeId;
+			return (tool !== "mnemon_runtime_memory" || config.idleReview.runtimeMemory) && allowsParticipation(config, type, "write", "automatic");
+		});
+	}
+	async review(parent, signal, admission) {
 		const config = this.runtimeSource.config.idleReview;
 		if (idleReviewBlockReason(parent, config.agentTeams) !== void 0) return {
 			delegated: false,
@@ -10930,6 +11067,13 @@ ${naturalRequest(request, target === void 0 ? REQUEST_LABELS : TARGETED_WRITE_LA
 			summary: "Idle review is paused by the Agent Teams compatibility setting.",
 			documentIds: []
 		};
+		const skipped = {
+			delegated: false,
+			action: "skipped",
+			summary: "Idle review has no applicable writable Source target.",
+			documentIds: []
+		};
+		if (!this.canReview(parent)) return skipped;
 		let preferred = config.provider;
 		if (preferred === "fork") try {
 			this.provider("fork");
@@ -10942,24 +11086,40 @@ ${naturalRequest(request, target === void 0 ? REQUEST_LABELS : TARGETED_WRITE_LA
 			};
 			preferred = "spawn";
 		}
-		const prompt = preferred === "fork" ? "Review the inherited completed checkpoint now." : reviewCheckpoint(parent.session, config.maxContextChars);
-		const base = reviewPersona(config.runtimeMemory);
-		const persona = preferred === "fork" ? base : base.replaceAll("inherited", "supplied bounded");
-		const tools = config.runtimeMemory ? REVIEW_TOOLS : REVIEW_TOOLS.filter((tool) => tool !== "mnemon_runtime_memory");
-		const writers = tools.filter((tool) => tool !== "mnemon_document_search");
-		const { provider, runId, result } = await this.delegate(parent, "review", "Mnemon idle checkpoint review", prompt, tools, WRITE_SCHEMA, signal, preferred, persona, { terminalTools: writers });
-		const value = object$6(result.structured);
-		return {
-			delegated: true,
-			runId,
-			provider,
-			summary: typeof value.summary === "string" ? value.summary : "",
-			action: typeof value.action === "string" ? value.action : "failed",
-			memoryBodyIds: strings(value.memoryBodyIds),
-			documentIds: strings(value.documentIds)
-		};
+		const execution = await this.runtimeSource.executions.workflow(parent, "review", signal);
+		try {
+			if (admission !== void 0) {
+				execution.signal.throwIfAborted();
+				admission();
+			}
+			const view = execution.context.view;
+			const instances = execution.graph.memoryComposition.generation(view.runtimeGeneration).sourceInstances();
+			const tools = this.reviewTools(parent).filter((tool) => {
+				if (tool === "mnemon_document_search") return true;
+				const entry = memoryTool(tool);
+				return view.actionOffers.some((offer) => offer.authority === void 0 && offer.sourceActionId === entry.operation && instances.some((instance) => instance.sourceInstanceKey === offer.sourceInstanceKey && instance.sourceTypeId === entry.sourceTypeId));
+			});
+			const writers = tools.filter((tool) => tool !== "mnemon_document_search");
+			if (writers.length === 0) return skipped;
+			const prompt = preferred === "fork" ? "Review the inherited completed checkpoint now." : reviewCheckpoint(parent.session, config.maxContextChars);
+			const base = reviewPersona(tools.includes("mnemon_runtime_memory"));
+			const persona = preferred === "fork" ? base : base.replaceAll("inherited", "supplied bounded");
+			const { provider, runId, result } = await this.delegate(parent, "review", "Mnemon idle checkpoint review", prompt, tools, WRITE_SCHEMA, execution.signal, preferred, persona, { terminalTools: writers }, void 0, void 0, admission);
+			const value = object$6(result.structured);
+			return {
+				delegated: true,
+				runId,
+				provider,
+				summary: typeof value.summary === "string" ? value.summary : "",
+				action: typeof value.action === "string" ? value.action : "failed",
+				memoryBodyIds: strings(value.memoryBodyIds),
+				documentIds: strings(value.documentIds)
+			};
+		} finally {
+			execution.release();
+		}
 	}
-	async delegate(parent, operation, label, prompt, tools, outputSchema, signal, preferredProvider = "spawn", persona = WRITE_PERSONA, recovery, guard, route) {
+	async delegate(parent, operation, label, prompt, tools, outputSchema, signal, preferredProvider = "spawn", persona = WRITE_PERSONA, recovery, guard, route, admission) {
 		if (this.disposed) throw new Error("dsh-mnemon subagent coordinator is disposed");
 		const provider = this.provider(preferredProvider);
 		assertDshOutputSchema(outputSchema);
@@ -11076,19 +11236,25 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 				model: fixed.model
 			};
 			const host = this.resultRuntime;
-			const start = () => startWithContinuationTurns(host, parent, () => startSubagent(this.subagents, host.agents, provider, {
-				label,
-				prompt: [{
-					type: "text",
-					text: `${delegatedTaskLine(operation)}\n${prompt}`
-				}],
-				parent,
-				signal,
-				...resolvedAgentOptions === void 0 ? {} : { agentOptions: resolvedAgentOptions },
-				maxDepth: 1,
-				toolFilter: { allow: [...tools, resultToolName] },
-				persona: completionPersona
-			}, host));
+			const start = () => startWithContinuationTurns(host, parent, () => {
+				if (operation === "review") {
+					signal.throwIfAborted();
+					admission?.();
+				}
+				return startSubagent(this.subagents, host.agents, provider, {
+					label,
+					prompt: [{
+						type: "text",
+						text: `${delegatedTaskLine(operation)}\n${prompt}`
+					}],
+					parent,
+					signal,
+					...resolvedAgentOptions === void 0 ? {} : { agentOptions: resolvedAgentOptions },
+					maxDepth: 1,
+					toolFilter: { allow: [...this.availableTools(parent, tools), resultToolName] },
+					persona: completionPersona
+				}, host);
+			});
 			run = operation === "review" ? await startGuardedReview(this.resultRuntime, parent, [...tools, resultToolName], start, (child) => {
 				reviewChildId = child.id;
 			}, reviewLayerPolicy()) : guard !== void 0 ? await startGuardedChild(this.resultRuntime, parent, start, guard, {
@@ -11765,6 +11931,157 @@ var AgentMemoryTurn = class {
 	}
 };
 //#endregion
+//#region src/host/idle-review-watermark.ts
+const MAX_STATE_BYTES = 16384;
+const MAX_TIMESTAMP = 864e13;
+function validAttempts(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function validTimestamp(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= MAX_TIMESTAMP;
+}
+/** Messages deliberately omit filesystem paths, session ids and raw input. */
+function failure$2(error) {
+	const code = error?.code;
+	const detail = code === "EBUSY" ? " (busy)" : typeof code === "string" && /^[A-Z_]+$/u.test(code) ? ` (${code})` : "";
+	return new Error(`Idle review watermark unavailable${detail}. Automatic review is paused. Stop Hosts using this storage root, repair this session's state or lock under state/idle-review, then reopen the session.`, { cause: error });
+}
+/** Host-local admission state, deliberately outside Packs and Git sync. */
+var IdleReviewWatermarkStore = class {
+	sessionId;
+	directory;
+	path;
+	constructor(directory, sessionId) {
+		this.sessionId = sessionId;
+		if (!sessionId || Buffer.byteLength(sessionId) > 4096 || Buffer.byteLength(JSON.stringify(sessionId)) > 16128) throw failure$2(void 0);
+		this.directory = join(resolve(directory), "state", "idle-review");
+		this.path = join(this.directory, createHash("sha256").update(sessionId).digest("hex") + ".json");
+	}
+	load() {
+		let descriptor;
+		try {
+			try {
+				descriptor = fs.openSync(this.path, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0) | (fs.constants.O_NONBLOCK ?? 0));
+			} catch (error) {
+				if (error.code === "ENOENT") return {
+					version: 1,
+					sessionId: this.sessionId,
+					attempts: 0,
+					lastReviewAttemptAt: null
+				};
+				throw error;
+			}
+			const info = fs.fstatSync(descriptor);
+			if (!info.isFile() || info.size > MAX_STATE_BYTES) throw new Error("invalid state file");
+			const bytes = Buffer.alloc(16385);
+			let length = 0;
+			while (length < bytes.length) {
+				const count = fs.readSync(descriptor, bytes, length, bytes.length - length, null);
+				if (count === 0) break;
+				length += count;
+			}
+			if (length > MAX_STATE_BYTES) throw new Error("oversized state");
+			const value = JSON.parse(bytes.subarray(0, length).toString("utf8"));
+			if (value === null || typeof value !== "object") throw new Error("invalid state");
+			const state = value;
+			if (state.version !== 1 || state.sessionId !== this.sessionId || !validAttempts(state.attempts) || (state.attempts === 0 ? state.lastReviewAttemptAt !== null : !validTimestamp(state.lastReviewAttemptAt))) throw new Error("invalid state");
+			return {
+				version: 1,
+				sessionId: this.sessionId,
+				attempts: state.attempts,
+				lastReviewAttemptAt: state.lastReviewAttemptAt
+			};
+		} catch (error) {
+			throw failure$2(error);
+		} finally {
+			if (descriptor !== void 0) try {
+				fs.closeSync(descriptor);
+			} catch (error) {
+				throw failure$2(error);
+			}
+		}
+	}
+	/** Preserve already-used in-process quota on opt-in without admitting work. */
+	restore(floor) {
+		if (floor === void 0 || floor.attempts === 0 && floor.lastReviewAttemptAt === null) return this.load();
+		return this.withLock(() => {
+			const saved = this.load();
+			const merged = this.merge(saved, floor);
+			if (merged.attempts !== saved.attempts || merged.lastReviewAttemptAt !== saved.lastReviewAttemptAt) this.write(merged);
+			return merged;
+		});
+	}
+	reserve(policy) {
+		if (!validTimestamp(policy.now) || !validAttempts(policy.maxPerSession) || !validAttempts(policy.minIntervalMs)) throw failure$2(void 0);
+		return this.withLock(() => {
+			const saved = this.merge(this.load(), policy.floor);
+			if (saved.attempts >= policy.maxPerSession || policy.now - (saved.lastReviewAttemptAt ?? -Infinity) < policy.minIntervalMs) return void 0;
+			const next = {
+				version: 1,
+				sessionId: this.sessionId,
+				attempts: saved.attempts + 1,
+				lastReviewAttemptAt: policy.now
+			};
+			this.write(next);
+			return next;
+		});
+	}
+	merge(saved, floor) {
+		if (floor === void 0) return saved;
+		if (!validAttempts(floor.attempts) || (floor.attempts === 0 ? floor.lastReviewAttemptAt !== null : !validTimestamp(floor.lastReviewAttemptAt))) throw failure$2(void 0);
+		const previous = Math.max(saved.lastReviewAttemptAt ?? -Infinity, floor.lastReviewAttemptAt ?? -Infinity);
+		return {
+			version: 1,
+			sessionId: this.sessionId,
+			attempts: Math.max(saved.attempts, floor.attempts),
+			lastReviewAttemptAt: previous === -Infinity ? null : previous
+		};
+	}
+	write(state) {
+		const temporary = this.path + "." + randomUUID() + ".tmp";
+		try {
+			fs.writeFileSync(temporary, JSON.stringify(state) + "\n", {
+				mode: 384,
+				flag: "wx"
+			});
+			fs.renameSync(temporary, this.path);
+		} finally {
+			fs.rmSync(temporary, { force: true });
+		}
+	}
+	/**
+	* One bounded synchronous read/check/write critical section. Exclusive mkdir
+	* protects independent Hosts too; contention fails closed without stale-lock
+	* takeover. Never hold this lock while starting or awaiting model work.
+	*/
+	withLock(operation) {
+		const lock = this.path + ".lock";
+		let held = false;
+		try {
+			fs.mkdirSync(this.directory, {
+				recursive: true,
+				mode: 448
+			});
+			try {
+				fs.mkdirSync(lock, { mode: 448 });
+			} catch (error) {
+				if (error.code === "EEXIST") throw Object.assign(/* @__PURE__ */ new Error("busy"), { code: "EBUSY" });
+				throw error;
+			}
+			held = true;
+			return operation();
+		} catch (error) {
+			throw failure$2(error);
+		} finally {
+			if (held) try {
+				fs.rmdirSync(lock);
+			} catch (error) {
+				throw failure$2(error);
+			}
+		}
+	}
+};
+//#endregion
 //#region src/host/lifecycle.ts
 function modelService(value) {
 	if (typeof value !== "object" || value === null || !("currentSelection" in value) || typeof value.currentSelection !== "function") return void 0;
@@ -11858,6 +12175,7 @@ var MnemonAgentLifecycle = class {
 	config;
 	counters;
 	memoryTurn;
+	runtimeDirectory;
 	primePending = true;
 	startSource;
 	guidedTurns = /* @__PURE__ */ new Set();
@@ -11874,10 +12192,21 @@ var MnemonAgentLifecycle = class {
 	idleReviewTimer;
 	reviewController;
 	reviewRunning = false;
+	reviewAccessBlocked = false;
 	lastReviewAt;
 	lastReviewAction;
 	lastReviewScore;
 	lastReviewDocumentIds;
+	disposed = false;
+	reviewEpoch = 0;
+	observedReviewPolicy;
+	watermarkEnabled = false;
+	/** Only this Agent's observed usage, attributed to the graph that composed each checkpoint. */
+	reviewUsage = /* @__PURE__ */ new Map();
+	watermarkKey;
+	watermarkStore;
+	watermarkError;
+	restoredAttempts = 0;
 	idleReviewAttempts = 0;
 	lastReviewAttemptAt;
 	lastReviewFailure;
@@ -11885,15 +12214,18 @@ var MnemonAgentLifecycle = class {
 	lastAt;
 	lastError;
 	composedTurn;
-	constructor(agent, coordinator, config, counters, source, memoryTurn) {
+	constructor(agent, coordinator, config, counters, source, memoryTurn, runtimeDirectory) {
 		this.agent = agent;
 		this.coordinator = coordinator;
 		this.config = config;
 		this.counters = counters;
 		this.memoryTurn = memoryTurn;
+		this.runtimeDirectory = runtimeDirectory;
 		this.startSource = source;
 	}
 	start() {
+		this.restoreWatermark();
+		this.observedReviewPolicy = this.reviewPolicy();
 		const disposers = [
 			this.agent.ctx.on("session/event", ((session, event) => this.sessionEvent(session, event))),
 			this.agent.ctx.on("system-prompt/assemble", ((assembly, context, next) => this.assemblePrompt(assembly, context, next))),
@@ -11901,12 +12233,14 @@ var MnemonAgentLifecycle = class {
 			this.agent.ctx.on("agent/turn-stopping", ((payload) => this.finishTurn(payload)))
 		];
 		return () => {
+			this.disposed = true;
 			this.releaseView();
 			this.cancelIdleReview(true);
 			for (const dispose of disposers.reverse()) dispose();
 		};
 	}
 	snapshot() {
+		this.restoreWatermark();
 		return {
 			sessionId: this.agent.id,
 			status: this.agent.status,
@@ -11918,8 +12252,14 @@ var MnemonAgentLifecycle = class {
 			reviewRunning: this.reviewRunning,
 			reviewActivity: this.reviewActivity(),
 			idleReviewAttempts: this.idleReviewAttempts,
-			...idleReviewBlockReason(this.agent, this.config.idleReview.agentTeams) === void 0 ? {} : { idleReviewBlocked: "agent-team" },
-			...this.lastReviewAttemptAt === void 0 ? {} : { nextReviewAt: new Date(this.lastReviewAttemptAt + this.config.idleReview.minIntervalMs).toISOString() },
+			...this.config.idleReview.persistWatermark ? { idleReviewWatermark: {
+				state: this.watermarkError === void 0 ? "ready" : "error",
+				restoredAttempts: this.restoredAttempts,
+				maxPerSession: this.config.idleReview.maxPerSession,
+				...this.watermarkError === void 0 ? {} : { error: this.watermarkError }
+			} } : {},
+			...idleReviewBlockReason(this.agent, this.config.idleReview.agentTeams) !== void 0 ? { idleReviewBlocked: "agent-team" } : this.reviewAccessBlocked ? { idleReviewBlocked: "tool-access" } : {},
+			...this.lastReviewAttemptAt === void 0 ? {} : { nextReviewAt: new Date(Math.min(864e13, this.lastReviewAttemptAt + this.config.idleReview.minIntervalMs)).toISOString() },
 			...this.lastReviewFailure === void 0 ? {} : { lastReviewFailure: this.lastReviewFailure },
 			lastPhase: this.lastPhase,
 			...this.lastReviewAt === void 0 ? {} : { lastReviewAt: this.lastReviewAt },
@@ -12042,15 +12382,17 @@ var MnemonAgentLifecycle = class {
 	scheduleIdleReview(turn) {
 		this.cancelIdleReview(true);
 		this.recordComposedTurn(turn);
-		if (!this.idleReviewAllowed()) return;
+		if (!this.restoreWatermark() || !this.idleReviewAllowed()) return;
 		const activity = this.ensureTurnActivity(turn);
 		const tools = completedToolActivity(this.agent.session.snapshotEvents(), turn);
 		activity.toolCallCount = tools.count;
 		activity.toolNames = tools.names;
 		if (!this.reviewActivity().eligible || !this.reviewAdmitted(turn)) return;
+		const epoch = this.reviewEpoch;
+		const policy = this.reviewPolicy();
 		this.idleReviewTimer = setTimeout(() => {
 			this.idleReviewTimer = void 0;
-			if (!this.idleReviewAllowed() || this.reviewRunning) return;
+			if (epoch !== this.reviewEpoch || policy !== this.reviewPolicy() || !this.idleReviewAllowed() || this.reviewRunning) return;
 			if (this.lastReviewAttemptAt !== void 0 && Date.now() < this.lastReviewAttemptAt + this.config.idleReview.minIntervalMs) {
 				this.scheduleIdleReview(turn);
 				return;
@@ -12058,7 +12400,73 @@ var MnemonAgentLifecycle = class {
 			if (this.agent.status !== "idle") return;
 			if (!this.agent.session.snapshotEvents().some((event) => event.type === "turn/end" && eventTurn(event) === turn) || !this.reviewActivity().eligible || !this.reviewAdmitted(turn)) return;
 			this.runIdleReview();
-		}, Math.max(this.config.idleReviewMs, (this.lastReviewAttemptAt ?? -Infinity) + this.config.idleReview.minIntervalMs - Date.now()));
+		}, Math.min(2147483647, Math.max(this.config.idleReviewMs, (this.lastReviewAttemptAt ?? -Infinity) + this.config.idleReview.minIntervalMs - Date.now())));
+	}
+	/** Resolve only the graph actually serving this parent, never a selected View or startup cwd. */
+	restoreWatermark() {
+		if (!this.config.idleReview.persistWatermark) {
+			this.watermarkEnabled = false;
+			return true;
+		}
+		try {
+			const directory = this.runtimeDirectory?.();
+			if (directory === void 0 || directory.trim() === "") throw new Error("runtime storage unavailable");
+			const key = JSON.stringify([resolve(directory), this.agent.id]);
+			if (this.watermarkKey === key && this.watermarkEnabled) return this.watermarkError === void 0;
+			const sameRoot = this.watermarkKey === key;
+			this.watermarkEnabled = true;
+			this.watermarkKey = key;
+			this.watermarkStore = new IdleReviewWatermarkStore(directory, this.agent.id);
+			this.watermarkError = void 0;
+			this.restoredAttempts = 0;
+			const floor = this.reviewUsage.get(resolve(directory));
+			if (!sameRoot) {
+				this.idleReviewAttempts = floor?.attempts ?? 0;
+				this.lastReviewAttemptAt = floor?.lastReviewAttemptAt ?? void 0;
+			}
+			const state = this.watermarkStore.restore(floor);
+			this.restoredAttempts = state.attempts;
+			this.idleReviewAttempts = state.attempts;
+			this.lastReviewAttemptAt = state.lastReviewAttemptAt ?? void 0;
+			this.reviewUsage.set(resolve(directory), state);
+			return true;
+		} catch (error) {
+			this.pauseWatermark(error);
+			return false;
+		}
+	}
+	configurationChanged() {
+		const policy = this.reviewPolicy();
+		if (policy !== this.observedReviewPolicy) {
+			this.cancelIdleReview(true);
+			this.reviewAccessBlocked = false;
+		}
+		this.observedReviewPolicy = policy;
+		this.restoreWatermark();
+	}
+	pauseWatermark(error) {
+		const message = error instanceof Error && error.message.startsWith("Idle review watermark unavailable") ? error.message : "Idle review watermark unavailable. Automatic review is paused. Stop Hosts using this storage root, repair this session's state or lock under state/idle-review, then reopen the session.";
+		this.watermarkError = message;
+	}
+	/** Policy/root changes invalidate an already queued checkpoint instead of catching up. */
+	reviewPolicy() {
+		try {
+			return JSON.stringify([
+				this.config.idleReview.persistWatermark ? this.runtimeDirectory?.() : void 0,
+				this.config.lifecycleEnabled,
+				this.config.writeEnabled,
+				this.config.storageScope,
+				this.config.dataDir,
+				this.config.writebackMode,
+				this.config.idleReviewMs,
+				this.config.idleReview,
+				this.config.taskAgentModel,
+				mainStrategyTypeId(this.config)
+			]);
+		} catch (error) {
+			if (this.config.idleReview.persistWatermark) this.pauseWatermark(error);
+			return;
+		}
 	}
 	/** Which Strategy composed the turn, while its View is still pinned, and whether it declares idle review. */
 	recordComposedTurn(turn) {
@@ -12069,7 +12477,8 @@ var MnemonAgentLifecycle = class {
 			this.composedTurn = {
 				turn,
 				typeId: strategy.typeId,
-				idleReview: strategyDrives(strategy, "idle-review")
+				idleReview: strategyDrives(strategy, "idle-review"),
+				directory: pinned.graph.directory
 			};
 		} else if (this.composedTurn?.turn !== turn) this.composedTurn = void 0;
 	}
@@ -12086,19 +12495,63 @@ var MnemonAgentLifecycle = class {
 		if (this.memoryTurn === void 0) return strategyDrives({ typeId }, "idle-review");
 		return this.composedTurn?.typeId === typeId && this.composedTurn.idleReview;
 	}
-	idleReviewAllowed() {
-		return this.config.lifecycleEnabled && this.config.writeEnabled && this.config.writebackMode === "guided" && this.config.idleReview.enabled && this.idleReviewAttempts < this.config.idleReview.maxPerSession && idleReviewBlockReason(this.agent, this.config.idleReview.agentTeams) === void 0 && this.strategyDrivesIdleReview();
+	idleReviewAllowed(reserved = false) {
+		return !this.disposed && (!this.config.idleReview.persistWatermark || this.watermarkError === void 0) && this.config.lifecycleEnabled && this.config.writeEnabled && this.config.writebackMode === "guided" && this.config.idleReview.enabled && (reserved || this.idleReviewAttempts < this.config.idleReview.maxPerSession) && idleReviewBlockReason(this.agent, this.config.idleReview.agentTeams) === void 0 && this.strategyDrivesIdleReview() && this.coordinator.canReview(this.agent);
 	}
 	async runIdleReview() {
 		const controller = new AbortController();
 		const triggeredScore = this.reviewActivity().score;
-		this.idleReviewAttempts += 1;
-		this.lastReviewAttemptAt = Date.now();
+		const epoch = this.reviewEpoch;
+		const policy = this.reviewPolicy();
 		this.reviewRunning = true;
 		this.reviewController = controller;
-		this.mark("review");
 		try {
-			const result = await this.coordinator.review(this.agent, controller.signal);
+			const available = await this.coordinator.checkReviewAccess(this.agent, controller.signal);
+			if (epoch !== this.reviewEpoch || policy !== this.reviewPolicy() || !this.idleReviewAllowed()) controller.abort(/* @__PURE__ */ new Error("Automatic idle review admission changed"));
+			controller.signal.throwIfAborted();
+			this.reviewAccessBlocked = !available;
+			if (!available) return;
+			if (this.config.idleReview.persistWatermark) try {
+				if (!this.restoreWatermark() || this.watermarkStore === void 0 || !this.idleReviewAllowed()) return;
+				const reserved = this.watermarkStore.reserve({
+					...this.config.idleReview,
+					now: Date.now(),
+					floor: {
+						attempts: this.idleReviewAttempts,
+						lastReviewAttemptAt: this.lastReviewAttemptAt ?? null
+					}
+				});
+				const state = reserved ?? this.watermarkStore.load();
+				this.idleReviewAttempts = Math.max(this.idleReviewAttempts, state.attempts);
+				this.lastReviewAttemptAt = Math.max(this.lastReviewAttemptAt ?? -Infinity, state.lastReviewAttemptAt ?? -Infinity);
+				if (this.lastReviewAttemptAt === -Infinity) this.lastReviewAttemptAt = void 0;
+				const directory = this.runtimeDirectory?.();
+				if (directory !== void 0) this.reviewUsage.set(resolve(directory), {
+					attempts: this.idleReviewAttempts,
+					lastReviewAttemptAt: this.lastReviewAttemptAt ?? null
+				});
+				if (reserved === void 0) return;
+			} catch (error) {
+				this.pauseWatermark(error);
+				return;
+			}
+			else {
+				this.idleReviewAttempts += 1;
+				this.lastReviewAttemptAt = Date.now();
+				const directory = this.composedTurn?.directory;
+				if (directory !== void 0) {
+					const key = resolve(directory);
+					this.reviewUsage.set(key, {
+						attempts: (this.reviewUsage.get(key)?.attempts ?? 0) + 1,
+						lastReviewAttemptAt: this.lastReviewAttemptAt
+					});
+				}
+			}
+			this.mark("review");
+			const result = await this.coordinator.review(this.agent, controller.signal, () => {
+				if (epoch !== this.reviewEpoch || policy !== this.reviewPolicy() || !this.idleReviewAllowed(true)) controller.abort(/* @__PURE__ */ new Error("Automatic idle review admission changed"));
+				controller.signal.throwIfAborted();
+			});
 			if (controller.signal.aborted) return;
 			this.lastReviewAt = (/* @__PURE__ */ new Date()).toISOString();
 			this.lastReviewAction = result.action;
@@ -12119,6 +12572,7 @@ var MnemonAgentLifecycle = class {
 		}
 	}
 	cancelIdleReview(abortRunning) {
+		this.reviewEpoch += 1;
 		if (this.idleReviewTimer !== void 0) clearTimeout(this.idleReviewTimer);
 		this.idleReviewTimer = void 0;
 		if (abortRunning) this.reviewController?.abort();
@@ -12282,11 +12736,15 @@ var MnemonLifecycle = class {
 		return this.skillEvolution.reviewNow(this.liveAgent(sessionId));
 	}
 	start() {
+		const stopChanged = this.runtimeSource?.onChanged?.(() => {
+			for (const { lifecycle } of this.owners.values()) lifecycle.configurationChanged();
+		});
 		const stopCreated = this.ctx.on("agent/created", (({ agent, source }) => {
 			this.install(agent, source);
 		}));
 		for (const agent of this.ctx.agents.roots()) this.install(agent, "adopted");
 		return () => {
+			stopChanged?.();
 			stopCreated();
 			for (const dispose of [...this.children.values()].reverse()) dispose();
 			for (const owner of [...this.owners.values()].reverse()) owner.dispose();
@@ -12791,7 +13249,7 @@ var MnemonLifecycle = class {
 		}
 		if (!this.ctx.agents.roots().includes(agent)) return;
 		const memoryTurn = this.runtimeSource === void 0 ? void 0 : new AgentMemoryTurn(agent, this.runtimeSource);
-		const lifecycle = new MnemonAgentLifecycle(agent, this.coordinator, this.config, this.counters, source, memoryTurn);
+		const lifecycle = new MnemonAgentLifecycle(agent, this.coordinator, this.config, this.counters, source, memoryTurn, () => this.runtimeSource?.forAgent(agent).directory);
 		let dispose;
 		dispose = agent.ctx.effect(() => {
 			const stop = lifecycle.start();
@@ -15333,16 +15791,59 @@ function documentActionReceipt(receipt) {
 }
 /**
 * Named product tools are views over the same Source Route/Action protocol. Each family registers its tools in the
-* order the model has always been given them, which puts Memory Spaces' reads before the Documents tools and its
-* writes after the runtime memory tool.
+* historical registry order, which puts Memory Spaces' reads before the Documents tools and its writes after
+* the runtime memory tool. DSH's prompt assembler independently orders wire schemas.
 */
-function registerTools(ctx, runtimeSource, coordinator) {
+function registerTools(ctx, runtimeSource, coordinator, contributions, initialReady) {
+	const definitions = [];
+	const catalog = { tools: { register: (tool) => {
+		definitions.push(tool);
+	} } };
 	const helpers = toolHelpers(runtimeSource);
-	registerViewTools(ctx, helpers, coordinator);
-	registerMemorySpaceReadTools(ctx, helpers, coordinator);
-	registerDocumentTools(ctx, helpers, coordinator);
-	registerRuntimeTools(ctx, helpers, coordinator);
-	registerMemorySpaceWriteTools(ctx, helpers, coordinator);
+	registerViewTools(catalog, helpers, coordinator);
+	registerMemorySpaceReadTools(catalog, helpers, coordinator);
+	registerDocumentTools(catalog, helpers, coordinator);
+	registerRuntimeTools(catalog, helpers, coordinator);
+	registerMemorySpaceWriteTools(catalog, helpers, coordinator);
+	const registered = /* @__PURE__ */ new Map();
+	let active = true;
+	let ready = initialReady === void 0;
+	const reconcile = (snapshot) => {
+		const types = new Set(snapshot.sources.map((source) => source.definition.manifest.typeId));
+		for (const tool of definitions) {
+			const type = memoryTool(tool.name)?.sourceTypeId;
+			if (!(type === void 0 || ready && types.has(type))) {
+				registered.get(tool.name)?.();
+				registered.delete(tool.name);
+			} else if (!registered.has(tool.name)) {
+				const dispose = ctx.tools.register(tool);
+				if (typeof dispose !== "function") throw new Error("dsh-mnemon tool registration did not return a disposer: " + tool.name);
+				registered.set(tool.name, dispose);
+			}
+		}
+	};
+	const unsubscribe = contributions.onCommittedContributionsChanged(reconcile);
+	const dispose = () => {
+		if (!active) return;
+		active = false;
+		unsubscribe();
+		for (const release of registered.values()) release();
+		registered.clear();
+	};
+	try {
+		reconcile(contributions.committedContributionSnapshot());
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+	initialReady?.then(() => {
+		if (!active) return;
+		ready = true;
+		reconcile(contributions.committedContributionSnapshot());
+	}).catch((error) => {
+		if (active) console.warn("dsh-mnemon: could not initialize Source tool families", error);
+	});
+	return dispose;
 }
 /** What the handlers of every family share: the calling Agent's runtime graph and Sources, its checks, and a Source Action call. */
 function toolHelpers(runtimeSource) {
@@ -18274,7 +18775,10 @@ function apply(rawContext, rawConfig = {}) {
 			runtime.dispose();
 		};
 	}, "dsh-mnemon.lifecycle-root()");
-	registerTools(ctx, runtime, coordinator);
+	ctx.effect(() => {
+		const loader = ctx.get("loader");
+		return registerTools(ctx, runtime, coordinator, extensions, loader?.await?.());
+	}, "dsh-mnemon: Source tool lifecycle");
 	registerCommands(ctx.commands, runtime, coordinator);
 	registerGuidance(ctx, resolved);
 	ctx.inject(["connection", "webServer"], (webContext) => {