dsh-mnemon 0.5.37 → 0.5.39

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 { d as truncate, 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-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";
@@ -259,7 +259,7 @@ const MNEMON_SYNC_CHANNEL = "/dsh-mnemon-sync";
 const MNEMON_SYNC_TOKEN_ENV = "MNEMON_SYNC_GIT_TOKEN";
 /**
 * What a storage root publishes before anyone configures it: the branch, the
-* directory inside it, and the commit identity used when no author is set. They
+* directory inside it, and the fallback when no author or Git identity is set. They
 * are declared with the wire constants because the settings form shows the same
 * defaults the Host would apply to an empty field.
 */
@@ -374,6 +374,7 @@ function isWorkspaceStorageScope(scope) {
 const DEFAULT_IDLE_REVIEW = {
 	enabled: true,
 	runtimeMemory: true,
+	persistWatermark: false,
 	provider: "spawn",
 	fallback: "spawn",
 	agentTeams: "pause",
@@ -386,6 +387,7 @@ const DEFAULT_SKILLS_CONFIG = Object.freeze({
 	evolution: false,
 	allowCreate: true,
 	allowUpdate: true,
+	targetScope: "user",
 	autoBacktest: true,
 	hints: true,
 	sidebar: false,
@@ -473,6 +475,11 @@ const SkillsConfig = z.object({
 	evolution: z.boolean().default(DEFAULT_SKILLS_CONFIG.evolution),
 	allowCreate: z.boolean().default(DEFAULT_SKILLS_CONFIG.allowCreate),
 	allowUpdate: z.boolean().default(DEFAULT_SKILLS_CONFIG.allowUpdate),
+	targetScope: z.union([
+		"storage",
+		"user",
+		"project"
+	]).default(DEFAULT_SKILLS_CONFIG.targetScope),
 	autoBacktest: z.boolean().default(DEFAULT_SKILLS_CONFIG.autoBacktest),
 	hints: z.boolean().default(DEFAULT_SKILLS_CONFIG.hints),
 	sidebar: z.boolean().default(DEFAULT_SKILLS_CONFIG.sidebar),
@@ -535,6 +542,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 +1265,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 +1361,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 +1629,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 +1650,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 +1711,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 +1725,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 +4002,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 +4143,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 +4291,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 +4322,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;
@@ -5329,7 +5337,7 @@ var MnemonGitSync = class {
 		if (committed) {
 			const identity = await this.commitIdentity(settings, signal);
 			const result = await this.git([
-				...identity,
+				...identity.args,
 				"commit",
 				"--quiet",
 				"-m",
@@ -5338,7 +5346,8 @@ var MnemonGitSync = class {
 				settings.subdir
 			], {
 				cwd: this.store.mirror(),
-				signal
+				signal,
+				env: identity.env
 			});
 			if (result.exitCode !== 0) throw new Error("git commit failed: " + tail(result.stderr || result.stdout));
 		}
@@ -5371,20 +5380,35 @@ var MnemonGitSync = class {
 		};
 	}
 	/**
-	* The identity a sync commit is recorded under: the one configured here, else the
-	* Git identity this machine has. A machine without one gets the channel's own
-	* rather than a failed commit, and rather than the account and host names Git
-	* would otherwise guess and publish.
+	* The saved default pair also appears in older settings that never selected an
+	* author. Like blank fields, it defers to Git in the mirror's directory; only a
+	* machine without a configured identity uses the channel's placeholder. Any
+	* other pair keeps its explicit fields, even when one matches a default value.
 	*/
 	async commitIdentity(settings, signal) {
-		const name = settings.authorName !== "" ? settings.authorName : await this.configured("user.name", signal) ?? "dsh-mnemon sync";
-		const email = settings.authorEmail !== "" ? settings.authorEmail : await this.configured("user.email", signal) ?? "mnemon@localhost";
-		return [
-			"-c",
-			"user.name=" + name,
-			"-c",
-			"user.email=" + email
-		];
+		const defaults = settings.authorName === "dsh-mnemon sync" && settings.authorEmail === "mnemon@localhost";
+		const authorName = defaults ? "" : settings.authorName;
+		const authorEmail = defaults ? "" : settings.authorEmail;
+		const name = authorName !== "" ? authorName : await this.configured("user.name", signal) ?? "dsh-mnemon sync";
+		const email = authorEmail !== "" ? authorEmail : await this.configured("user.email", signal) ?? "mnemon@localhost";
+		const env = {};
+		if (authorName !== "") {
+			env.GIT_AUTHOR_NAME = authorName;
+			env.GIT_COMMITTER_NAME = authorName;
+		}
+		if (authorEmail !== "") {
+			env.GIT_AUTHOR_EMAIL = authorEmail;
+			env.GIT_COMMITTER_EMAIL = authorEmail;
+		}
+		return {
+			args: [
+				"-c",
+				"user.name=" + name,
+				"-c",
+				"user.email=" + email
+			],
+			env
+		};
 	}
 	/** One Git setting as this machine resolves it, or nothing when no config sets it. */
 	async configured(key, signal) {
@@ -6115,7 +6139,7 @@ var MnemonGitSync = class {
 		const failure = rejectedPush(output) ? "push-rejected" : REMOTE_FAILURE[remoteIssueOf(output)];
 		return {
 			pushed: false,
-			reason: credential.token === void 0 && failure !== "push-rejected" ? "the commit stays local because no token is available: " + reason : reason,
+			reason: /\[remote rejected\]/iu.test(output) ? "the remote rejected this push; check its policy and the commit author in Sync > Advanced, then sync again: " + reason : credential.token === void 0 && failure !== "push-rejected" ? "the commit stays local because no token is available: " + reason : reason,
 			...failure === void 0 ? {} : { failure }
 		};
 	}
@@ -6277,7 +6301,10 @@ var MnemonGitSync = class {
 		try {
 			return await this.run(GIT_LABEL, prepared.args, {
 				timeoutMs: options.timeoutMs ?? 12e4,
-				env: gitEnvironment(),
+				env: gitEnvironment({
+					...process.env,
+					...options.env
+				}),
 				...options.cwd === void 0 ? {} : { cwd: options.cwd },
 				...options.signal === void 0 ? {} : { signal: options.signal },
 				...options.maxOutputBytes === void 0 ? {} : { maxOutputBytes: options.maxOutputBytes },
@@ -7490,6 +7517,7 @@ var LiveMnemonRuntime = class {
 	githubAuth;
 	autoBackupView;
 	closed = false;
+	changeListeners = /* @__PURE__ */ new Set();
 	config;
 	storage;
 	packs;
@@ -7531,6 +7559,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 +7578,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 +7603,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,148 +10194,535 @@ async function assertAutomaticMemoryWrite(host, parent) {
 	return host.writableSourceFor(parent, "memory-spaces", "remember");
 }
 //#endregion
-//#region src/host/subagent.ts
-function evidenceInsights(evidence) {
-	return evidence.items.map((item) => {
-		return {
-			...optionalObject(item.provenance) ?? {},
-			id: item.id,
-			content: item.text,
-			...item.score === void 0 ? {} : { score: item.score },
-			...item.revision === void 0 ? {} : { revision: item.revision }
-		};
-	});
-}
+//#region src/host/view-presentation.ts
 /**
-* Every task dsh-mnemon delegates to a child Agent starts with one line of its own, such as
-* `[dsh-mnemon:delegated review]` (#393). DSH records the task as the child's prompt from a
-* person, so a plugin that reads sessions, such as one that collects a workspace's work, can
-* rely on this line, documented as stable, to leave Mnemon's own children out.
+* The named tools bound to each Source type's Routes or Actions, from the tool table: these are
+* existing DSH product-tool bindings, not Core operation names. Tools that share one operation are
+* listed together, in table order, as the View's tool list names them.
 */
-const DELEGATED_TASK_PREFIX = "[dsh-mnemon:delegated ";
-function delegatedTaskLine(operation) {
-	return `${DELEGATED_TASK_PREFIX}${operation}]`;
-}
-const WRITE_TOOLS = [
-	...[
-		"mnemon_memory_bodies",
-		"mnemon_recall",
-		"mnemon_related"
-	],
-	"mnemon_remember",
-	"mnemon_link",
-	"mnemon_forget",
-	"mnemon_memory_body_create",
-	"mnemon_memory_body_update",
-	"mnemon_memory_body_merge"
-];
-const AUTONOMOUS_WRITE_TOOLS = WRITE_TOOLS.filter((tool) => tool !== "mnemon_forget");
-const EXPLICIT_WRITE_TOOLS = WRITE_TOOLS;
-const REVIEW_TOOLS = [
-	...["mnemon_document_search"],
-	"mnemon_runtime_memory",
-	"mnemon_document_create"
-];
-const RESULT_TOOL_NAME = "mnemon_subagent_result";
-/** How many finished delegated children stay refused memory tools if DSH resumes one. */
-const FINISHED_CHILDREN = 1e3;
-const FINISHED_CHILD_REFUSAL = "This Mnemon task has finished, so it no longer reads or changes memory. Reply without memory tools.";
-const RESULT_TOOL_INPUT_SCHEMA = {
-	type: "object",
-	properties: {
-		requestId: {
-			type: "string",
-			minLength: 1
-		},
-		result: {
-			type: "object",
-			additionalProperties: true
-		}
-	},
-	required: ["requestId", "result"],
-	additionalProperties: false
-};
-const RESULT_TOOL_OUTPUT_SCHEMA = {
-	type: "object",
-	properties: { recorded: {
-		type: "boolean",
-		const: true
-	} },
-	required: ["recorded"],
-	additionalProperties: false
-};
-const WRITE_OPERATION_RESULT_TOOL = {
-	remember: "mnemon_remember",
-	"supervised-writeback": "mnemon_remember",
-	link: "mnemon_link",
-	forget: "mnemon_forget",
-	"create-memory-body": "mnemon_memory_body_create",
-	"update-memory-body": "mnemon_memory_body_update",
-	"merge-memory-bodies": "mnemon_memory_body_merge"
-};
-var IdleReviewError = class extends Error {
-	review;
-	constructor(message, review, options) {
-		super(message, options);
-		this.review = review;
-		this.name = "IdleReviewError";
+function namedBindings(kind) {
+	const bindings = {};
+	for (const [name, tool] of memoryTools()) {
+		if (tool.sourceTypeId === void 0 || tool.operation === void 0 || tool.kind === "write" !== (kind === "action")) continue;
+		const operations = bindings[tool.sourceTypeId] ??= {};
+		const listed = operations[tool.operation];
+		operations[tool.operation] = listed === void 0 ? name : `${listed} / ${name}`;
 	}
-};
-/** What a memory saved without a vector means for recall, and how its vector comes. */
-const UNEMBEDDED_HINT = "Saved without a vector, because embedding did not succeed: semantic matching misses it until its vector is filled in, while keyword, link and recency recall still reach it. Once the embedding service answers, the user fills it in from Test status in the Mnemon Native embedding settings, which runs through the storage root and embedding settings DSH uses; a terminal mnemon command may reach neither.";
-/** The memories a write saved without a vector: Mnemon Native says so with `embedded: false` (#388). */
-function withoutVector(receipts) {
-	return receipts.filter((receipt) => isTool(receipt.name, "mnemon_remember")).flatMap((receipt) => {
-		const value = optionalObject(receipt.value);
-		if (value?.embedded !== false) return [];
-		return [{
-			...typeof value.memoryBodyId === "string" ? { memoryBodyId: value.memoryBodyId } : {},
-			...typeof value.id === "string" ? { id: value.id } : {}
-		}];
-	});
+	return bindings;
+}
+const ROUTE_TOOLS = namedBindings("route");
+const ACTION_TOOLS = namedBindings("action");
+const NAMED_SOURCE_TYPES = [.../* @__PURE__ */ new Set([...Object.keys(ROUTE_TOOLS), ...Object.keys(ACTION_TOOLS)])];
+/** Use a short availability list only where the Host has the matching named binding.
+* Unbound external operations retain exact ids and schemas in the generic envelope. */
+function modelMemoryWake(graph, turn) {
+	const generation = graph.memoryComposition.generation(turn.view.runtimeGeneration);
+	if (generation === void 0) throw new Error("Cannot present an unpinned Memory generation");
+	return graph.composableTurns.memoryWake(turn.view.id, memoryWakeBindings(generation, turn.view));
+}
+function presentMemoryWake(generation, view) {
+	return createMemoryWake(view, memoryWakeBindings(generation, view));
 }
-/** A Memory Space write tool: each switches on the space it goes to. */
-const SPACE_WRITE_TOOLS = /* @__PURE__ */ new Set(["mnemon_remember", "mnemon_link"]);
 /**
-* Holds a delegated write to the Memory Space its caller named, and keeps a writer
-* from switching a space back on: a write or a link switches on the space it goes to,
-* so a space that was inactive when the run started takes one only when the caller
-* named it (#387). A space the writer creates is not in `inactive` and takes its first
-* write. Saving a memory never merges spaces: a merge switches spaces on and off, and
-* is a request of its own.
+* Why a generic View tool names no id this turn's View offers, told apart (#390); undefined when
+* the id is offered. It names only what the MNEMON VIEW ROUTES envelope shows: an operation bound
+* to a named tool is offered through that tool, and the envelope does not list its id.
 */
-function spaceWriteGuard(target, inactive) {
-	return (execution) => {
-		if (isTool(execution.name, "mnemon_memory_body_merge")) return "Saving a memory never merges Memory Spaces; a merge is a request of its own. Write the memory, or finish without writing.";
-		const input = optionalObject(execution.arguments) ?? {};
-		const space = typeof input.memoryBodyId === "string" ? input.memoryBodyId.trim() : void 0;
-		if (target !== void 0) {
-			if (execution.name !== void 0 && SPACE_WRITE_TOOLS.has(execution.name) && space !== target) return `This write was requested for Memory Space ${JSON.stringify(target)}. Call ${execution.name} with memoryBodyId ${JSON.stringify(target)}, or finish without writing and say why it does not fit.`;
-			if (isTool(execution.name, "mnemon_memory_body_create", "mnemon_memory_body_update")) return `This write was requested for Memory Space ${JSON.stringify(target)}, so it creates or changes no space. Write there, or finish without writing and say why it does not fit.`;
-			return;
+function unofferedViewId(graph, turn, kind, id) {
+	const view = turn.view;
+	const offered = kind === "route" ? view.routes.map((route) => ({
+		id: route.id,
+		operation: route.sourceRouteId
+	})) : view.actionOffers.map((offer) => ({
+		id: offer.id,
+		operation: offer.sourceActionId
+	}));
+	const label = kind === "route" ? "memory View Route" : "memory ActionOffer";
+	if (typeof id !== "string" || id === "") return `${label} needs ${kind === "route" ? "routeId" : "offerId"}, the exact id of one it offers`;
+	if (offered.some((entry) => entry.id === id)) return void 0;
+	const generation = graph.memoryComposition.generation(view.runtimeGeneration);
+	const bindings = generation === void 0 ? {} : memoryWakeBindings(generation, view);
+	const named = (kind === "route" ? bindings.routes : bindings.actions) ?? {};
+	const short = id.split("/").at(-1);
+	const tools = [...new Set(offered.filter((entry) => named[entry.id] !== void 0 && (entry.operation === short || entry.id.split("/").at(-1) === short)).map((entry) => named[entry.id]))];
+	if (tools.length > 0) return `${label} is unavailable: ${id}; this View offers it as ${tools.join(" and ")}, so call that tool`;
+	const shown = offered.filter((entry) => named[entry.id] === void 0).map((entry) => entry.id);
+	if (shown.length === 0) return `${label} is unavailable: ${id}; MNEMON VIEW ROUTES offers none by id this turn, only the named tools in MNEMON VIEW TOOLS`;
+	const near = shown.filter((candidate) => candidate.split("/").at(-1) === short);
+	if (near.length === 1) return `${label} is unavailable: ${id}; ids are exact as MNEMON VIEW ROUTES lists them: ${JSON.stringify(near[0])}`;
+	const listed = [...near, ...shown.filter((candidate) => !near.includes(candidate))];
+	return `${label} is unavailable: ${id}; MNEMON VIEW ROUTES offers ${listed.slice(0, 12).map((candidate) => JSON.stringify(candidate)).join(", ")}${listed.length > 12 ? ` and ${listed.length - 12} more` : ""}`;
+}
+function memoryWakeBindings(generation, view) {
+	const instances = generation.sourceInstances();
+	const routes = {}, actions = {};
+	for (const typeId of NAMED_SOURCE_TYPES) {
+		const selected = namedToolInstance(instances.filter((source) => source.sourceTypeId === typeId), typeId);
+		if (selected === void 0) continue;
+		for (const route of view.routes.filter((route) => route.sourceInstanceKey === selected.sourceInstanceKey)) {
+			if (view.readGrants.find((grant) => grant.id === route.readGrantId)?.schema !== `dsh-mnemon.${typeId}/v1`) continue;
+			const tool = ROUTE_TOOLS[typeId]?.[route.sourceRouteId];
+			if (tool !== void 0) routes[route.id] = tool;
 		}
-		if (space === void 0 || !inactive.has(space)) return void 0;
-		if (execution.name !== void 0 && SPACE_WRITE_TOOLS.has(execution.name)) return `Memory Space ${JSON.stringify(space)} is switched off, and a write would switch it on. Write to an active space, or finish without writing and say which space would fit.`;
-		if (isTool(execution.name, "mnemon_memory_body_update") && input.active === true) return `Memory Space ${JSON.stringify(space)} is switched off; only the user switches it on.`;
+		for (const action of view.actionOffers.filter((action) => action.sourceInstanceKey === selected.sourceInstanceKey)) {
+			const tool = ACTION_TOOLS[typeId]?.[action.sourceActionId];
+			if (tool !== void 0) actions[action.id] = tool;
+		}
+	}
+	return {
+		routes,
+		actions
 	};
 }
-/**
-* Why a write cannot go to the Memory Space its caller named, before a writer runs (#387):
-* the space is unknown, its Provider is off or takes no writes, or it is switched off and
-* the caller did not ask to switch it on. A model names a space by its description, the
-* judgement that misplaced memories before; switching a space back on is its own request.
-*/
-function targetProblem(spaces, target, activate) {
-	const body = spaces.find((candidate) => candidate.id === target);
-	if (body === void 0) {
-		const known = spaces.slice(0, 20).map((candidate) => `${JSON.stringify(candidate.id)} (${candidate.name}${candidate.active ? "" : ", switched off"})`).join(", ");
-		return `Memory Space ${JSON.stringify(target)} does not exist. Name one by its id${known === "" ? "; there is none yet." : `: ${known}.`}`;
-	}
-	if (body.providerEnabled === false) return `Memory Space ${JSON.stringify(target)} uses ${body.provider.label}, which is turned off on the dsh-mnemon page under Plugins. Name another space.`;
-	if (body.provider.capabilities.remember !== true) return `Memory Space ${JSON.stringify(target)} (${body.provider.label}) does not take writes. Name another space.`;
-	if (!body.active && !activate) return `Memory Space ${JSON.stringify(target)} (${body.name}) is switched off, and a write would switch it back on. If the user wants it back, switch it on first with mnemon_memory_body_update (active: true); otherwise name an active space.`;
+/** Explicitly pick display fields; never copy grants, authority, or opaque Source state. */
+function inspectMemoryView(generation, view, state, turn, memoryText) {
+	return structuredClone({
+		id: view.id,
+		digest: view.digest,
+		generationId: view.runtimeGeneration,
+		createdAt: view.createdAt,
+		state,
+		...turn === void 0 ? {} : { turn },
+		strategyTypeId: view.strategyTypeId,
+		strategyInstanceKey: view.strategyInstanceKey,
+		extensions: view.strategyExtensions ?? [],
+		projection: view.projection.map(({ id, sourceInstanceKey, mode, text, revision }) => ({
+			id,
+			sourceInstanceKey,
+			mode,
+			text,
+			revision
+		})),
+		sourcePresentations: view.sourcePresentations ?? [],
+		routes: view.routes.map(({ id, sourceInstanceKey, sourceRouteId, description, maxCalls }) => ({
+			id,
+			sourceInstanceKey,
+			operationId: sourceRouteId,
+			description,
+			maxCalls
+		})),
+		actions: view.actionOffers.map(({ id, sourceInstanceKey, sourceActionId, description }) => ({
+			id,
+			sourceInstanceKey,
+			operationId: sourceActionId,
+			description
+		})),
+		memoryText: memoryText ?? presentMemoryWake(generation, view).text,
+		...view.guidance === void 0 ? {} : { guidance: view.guidance },
+		diagnostics: (view.diagnostics ?? []).map((diagnostic) => diagnostic.message)
+	});
 }
-/** Whether a write receipt put the memory in its space, or handed it to a Provider that confirms later. */
+//#endregion
+//#region src/host/agent-memory-turn.ts
+/** The durable log, not a parent session id, identifies the executing turn. */
+function openAgentTurn(agent) {
+	let open;
+	for (const event of agent.session.snapshotEvents()) {
+		const turn = typeof event.data.turn === "number" ? event.data.turn : void 0;
+		if (event.type === "turn/start" && turn !== void 0) open = turn;
+		else if (event.type === "turn/end" && turn === open) open = void 0;
+	}
+	return open;
+}
+/**
+* One Agent owns each turn pin. A child additionally retains its delegation
+* across parent completion, collection, and runtime swaps until it is disposed.
+*/
+var AgentMemoryTurn = class {
+	agent;
+	runtime;
+	delegation;
+	pinned;
+	/** A turn that runs without memory because no composition was serving when it began. */
+	unavailable;
+	warned;
+	pending;
+	generation = 0;
+	closed = false;
+	lastInspection;
+	lastWorkspace;
+	releaseDelegation;
+	constructor(agent, runtime, delegation) {
+		this.agent = agent;
+		this.runtime = runtime;
+		this.delegation = delegation;
+		if (delegation === void 0) return;
+		this.releaseDelegation = runtime.executions.retain(agent, delegation);
+	}
+	get current() {
+		return this.pinned;
+	}
+	/** Why the current turn has no View, when memory could not be composed for it. */
+	get unavailableReason() {
+		return this.unavailable?.reason;
+	}
+	inspect(workspaceRoot) {
+		if (this.lastInspection === void 0) return void 0;
+		if (workspaceRoot !== void 0 && resolve(workspaceRoot) !== this.lastWorkspace) return void 0;
+		return structuredClone({
+			...this.lastInspection,
+			state: this.pinned === void 0 ? "recent" : "active"
+		});
+	}
+	clearInspection() {
+		this.lastInspection = void 0;
+		this.lastWorkspace = void 0;
+	}
+	/** Capture now; descendants must not resolve a later parent turn on demand. */
+	delegate() {
+		if (this.closed) throw new Error("memory Agent lifetime has ended");
+		if (this.pinned !== void 0) return {
+			graph: this.pinned.graph,
+			scope: this.pinned.context.scope,
+			viewId: this.pinned.context.view.id
+		};
+		if (this.delegation !== void 0) return this.delegation;
+		const graph = this.runtime.forAgent(this.agent);
+		return {
+			graph,
+			scope: agentScope(this.agent, graph.config)
+		};
+	}
+	async begin(turn, signal) {
+		if (this.closed) throw new Error("memory Agent lifetime has ended");
+		signal?.throwIfAborted();
+		if (this.pinned?.turn === turn || this.unavailable?.turn === turn) return;
+		if (this.pending?.turn === turn) return this.pending.result;
+		this.end();
+		const generation = this.generation;
+		const controller = new AbortController();
+		const abort = () => controller.abort(signal.reason);
+		signal?.addEventListener("abort", abort, { once: true });
+		const result = this.pin(turn, generation, controller.signal).catch((error) => {
+			if (!isMemoryCompositionUnavailable(error) || this.closed || this.generation !== generation) throw error;
+			this.unavailable = {
+				turn,
+				reason: error.message
+			};
+			this.clearInspection();
+			if (this.warned !== error.message) console.warn(`[dsh-mnemon] this turn runs without memory: ${error.message}`);
+			this.warned = error.message;
+		});
+		this.pending = {
+			turn,
+			generation,
+			controller,
+			result
+		};
+		try {
+			await result;
+		} finally {
+			signal?.removeEventListener("abort", abort);
+			if (this.pending?.generation === generation) this.pending = void 0;
+		}
+	}
+	end(turn) {
+		if (turn !== void 0 && this.pinned?.turn !== turn && this.pending?.turn !== turn && this.unavailable?.turn !== turn) return;
+		this.generation += 1;
+		this.unavailable = void 0;
+		this.pending?.controller.abort(/* @__PURE__ */ new Error("memory turn ended during View preparation"));
+		this.pending = void 0;
+		const pinned = this.pinned;
+		this.pinned = void 0;
+		pinned?.release();
+	}
+	dispose() {
+		if (this.closed) return;
+		this.closed = true;
+		this.clearInspection();
+		try {
+			this.end();
+		} finally {
+			this.releaseDelegation?.();
+		}
+	}
+	async pin(turn, generation, signal) {
+		const execution = await this.runtime.executions.turn(this.agent, turn, signal, this.delegation);
+		const { graph, context } = execution;
+		try {
+			if (this.closed || this.generation !== generation) throw new Error("memory turn ended during View preparation");
+			signal?.throwIfAborted();
+			const inspection = inspectMemoryView(graph.memoryComposition.generation(context.view.runtimeGeneration), context.view, "active", turn, modelMemoryWake(graph, context).text);
+			this.pinned = {
+				turn,
+				graph,
+				context,
+				release: execution.release
+			};
+			this.warned = void 0;
+			this.lastInspection = inspection;
+			this.lastWorkspace = context.scope.workspaceId === void 0 ? void 0 : resolve(context.scope.workspaceId);
+		} catch (error) {
+			execution.release();
+			throw error;
+		}
+	}
+};
+//#endregion
+//#region src/host/tool-execution.ts
+/** DSH 0.2.2 exposes executor registration and batch dispatch together. */
+function usesToolBatchExecution(tools) {
+	return typeof tools.setExecutor === "function";
+}
+/** Preserve the Host's scoped executor, guards, policy and final result for one call. */
+async function executeHostTool(tools, input) {
+	if (tools.execute === void 0) throw new Error("The DSH tool execution service is unavailable");
+	if (!usesToolBatchExecution(tools)) return tools.execute(input);
+	const results = (await tools.execute({
+		calls: [{
+			type: "tool-call",
+			id: input.callId,
+			name: input.name,
+			arguments: JSON.stringify(input.arguments)
+		}],
+		agent: input.agent,
+		signal: input.signal
+	}))?.results;
+	const result = results?.[0];
+	if (!Array.isArray(results) || results.length !== 1 || result?.callId !== input.callId || typeof result.result?.isError !== "boolean") throw new Error("The DSH tool batch did not return the requested call outcome");
+	return result.result;
+}
+//#endregion
+//#region src/host/review-admission.ts
+const RESULT_TOOL = "mnemon_subagent_result";
+const CHECK_TIMEOUT_MS = 5e3;
+/** An in-turn no-op challenge through the mandatory review completion channel.
+* 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) || openAgentTurn(agent) === void 0) 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?.();
+		const attempt = async (codeMode) => {
+			combined.throwIfAborted();
+			const requestId = randomUUID();
+			const callId = randomUUID();
+			const challenge = {
+				agent,
+				accepted: false
+			};
+			this.challenges.set(requestId, challenge);
+			const revoke = () => this.challenges.delete(requestId);
+			combined.addEventListener("abort", revoke, { once: true });
+			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 = executeHostTool(tools, {
+					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 outcome = await pending.finally(cleanup);
+				combined.throwIfAborted();
+				return challenge.execution !== void 0 && challenge.accepted && outcome.isError === false;
+			} finally {
+				this.challenges.delete(requestId);
+				combined.removeEventListener("abort", revoke);
+				if (!executing) cleanup();
+			}
+		};
+		try {
+			if (await attempt(false)) return true;
+			return (usesToolBatchExecution(tools) || tools.get?.("run_code", agent) !== void 0) && await attempt(true);
+		} catch {
+			signal.throwIfAborted();
+			return false;
+		} finally {
+			clearTimeout(timeout);
+			this.controllers.delete(controller);
+		}
+	}
+};
+//#endregion
+//#region src/host/subagent.ts
+function evidenceInsights(evidence) {
+	return evidence.items.map((item) => {
+		return {
+			...optionalObject(item.provenance) ?? {},
+			id: item.id,
+			content: item.text,
+			...item.score === void 0 ? {} : { score: item.score },
+			...item.revision === void 0 ? {} : { revision: item.revision }
+		};
+	});
+}
+/**
+* Every task dsh-mnemon delegates to a child Agent starts with one line of its own, such as
+* `[dsh-mnemon:delegated review]` (#393). DSH records the task as the child's prompt from a
+* person, so a plugin that reads sessions, such as one that collects a workspace's work, can
+* rely on this line, documented as stable, to leave Mnemon's own children out.
+*/
+const DELEGATED_TASK_PREFIX = "[dsh-mnemon:delegated ";
+function delegatedTaskLine(operation) {
+	return `${DELEGATED_TASK_PREFIX}${operation}]`;
+}
+const WRITE_TOOLS = [
+	...[
+		"mnemon_memory_bodies",
+		"mnemon_recall",
+		"mnemon_related"
+	],
+	"mnemon_remember",
+	"mnemon_link",
+	"mnemon_forget",
+	"mnemon_memory_body_create",
+	"mnemon_memory_body_update",
+	"mnemon_memory_body_merge"
+];
+const AUTONOMOUS_WRITE_TOOLS = WRITE_TOOLS.filter((tool) => tool !== "mnemon_forget");
+const EXPLICIT_WRITE_TOOLS = WRITE_TOOLS;
+const REVIEW_TOOLS = [
+	...["mnemon_document_search"],
+	"mnemon_runtime_memory",
+	"mnemon_document_create"
+];
+const RESULT_TOOL_NAME = "mnemon_subagent_result";
+/** How many finished delegated children stay refused memory tools if DSH resumes one. */
+const FINISHED_CHILDREN = 1e3;
+const FINISHED_CHILD_REFUSAL = "This Mnemon task has finished, so it no longer reads or changes memory. Reply without memory tools.";
+const RESULT_TOOL_INPUT_SCHEMA = {
+	type: "object",
+	properties: {
+		requestId: {
+			type: "string",
+			minLength: 1
+		},
+		result: {
+			type: "object",
+			additionalProperties: true
+		}
+	},
+	required: ["requestId", "result"],
+	additionalProperties: false
+};
+const RESULT_TOOL_OUTPUT_SCHEMA = {
+	type: "object",
+	properties: { recorded: {
+		type: "boolean",
+		const: true
+	} },
+	required: ["recorded"],
+	additionalProperties: false
+};
+const WRITE_OPERATION_RESULT_TOOL = {
+	remember: "mnemon_remember",
+	"supervised-writeback": "mnemon_remember",
+	link: "mnemon_link",
+	forget: "mnemon_forget",
+	"create-memory-body": "mnemon_memory_body_create",
+	"update-memory-body": "mnemon_memory_body_update",
+	"merge-memory-bodies": "mnemon_memory_body_merge"
+};
+var IdleReviewError = class extends Error {
+	review;
+	constructor(message, review, options) {
+		super(message, options);
+		this.review = review;
+		this.name = "IdleReviewError";
+	}
+};
+/** What a memory saved without a vector means for recall, and how its vector comes. */
+const UNEMBEDDED_HINT = "Saved without a vector, because embedding did not succeed: semantic matching misses it until its vector is filled in, while keyword, link and recency recall still reach it. Once the embedding service answers, the user fills it in from Test status in the Mnemon Native embedding settings, which runs through the storage root and embedding settings DSH uses; a terminal mnemon command may reach neither.";
+/** The memories a write saved without a vector: Mnemon Native says so with `embedded: false` (#388). */
+function withoutVector(receipts) {
+	return receipts.filter((receipt) => isTool(receipt.name, "mnemon_remember")).flatMap((receipt) => {
+		const value = optionalObject(receipt.value);
+		if (value?.embedded !== false) return [];
+		return [{
+			...typeof value.memoryBodyId === "string" ? { memoryBodyId: value.memoryBodyId } : {},
+			...typeof value.id === "string" ? { id: value.id } : {}
+		}];
+	});
+}
+/** A Memory Space write tool: each switches on the space it goes to. */
+const SPACE_WRITE_TOOLS = /* @__PURE__ */ new Set(["mnemon_remember", "mnemon_link"]);
+/**
+* Holds a delegated write to the Memory Space its caller named, and keeps a writer
+* from switching a space back on: a write or a link switches on the space it goes to,
+* so a space that was inactive when the run started takes one only when the caller
+* named it (#387). A space the writer creates is not in `inactive` and takes its first
+* write. Saving a memory never merges spaces: a merge switches spaces on and off, and
+* is a request of its own.
+*/
+function spaceWriteGuard(target, inactive) {
+	return (execution) => {
+		if (isTool(execution.name, "mnemon_memory_body_merge")) return "Saving a memory never merges Memory Spaces; a merge is a request of its own. Write the memory, or finish without writing.";
+		const input = optionalObject(execution.arguments) ?? {};
+		const space = typeof input.memoryBodyId === "string" ? input.memoryBodyId.trim() : void 0;
+		if (target !== void 0) {
+			if (execution.name !== void 0 && SPACE_WRITE_TOOLS.has(execution.name) && space !== target) return `This write was requested for Memory Space ${JSON.stringify(target)}. Call ${execution.name} with memoryBodyId ${JSON.stringify(target)}, or finish without writing and say why it does not fit.`;
+			if (isTool(execution.name, "mnemon_memory_body_create", "mnemon_memory_body_update")) return `This write was requested for Memory Space ${JSON.stringify(target)}, so it creates or changes no space. Write there, or finish without writing and say why it does not fit.`;
+			return;
+		}
+		if (space === void 0 || !inactive.has(space)) return void 0;
+		if (execution.name !== void 0 && SPACE_WRITE_TOOLS.has(execution.name)) return `Memory Space ${JSON.stringify(space)} is switched off, and a write would switch it on. Write to an active space, or finish without writing and say which space would fit.`;
+		if (isTool(execution.name, "mnemon_memory_body_update") && input.active === true) return `Memory Space ${JSON.stringify(space)} is switched off; only the user switches it on.`;
+	};
+}
+/**
+* Why a write cannot go to the Memory Space its caller named, before a writer runs (#387):
+* the space is unknown, its Provider is off or takes no writes, or it is switched off and
+* the caller did not ask to switch it on. A model names a space by its description, the
+* judgement that misplaced memories before; switching a space back on is its own request.
+*/
+function targetProblem(spaces, target, activate) {
+	const body = spaces.find((candidate) => candidate.id === target);
+	if (body === void 0) {
+		const known = spaces.slice(0, 20).map((candidate) => `${JSON.stringify(candidate.id)} (${candidate.name}${candidate.active ? "" : ", switched off"})`).join(", ");
+		return `Memory Space ${JSON.stringify(target)} does not exist. Name one by its id${known === "" ? "; there is none yet." : `: ${known}.`}`;
+	}
+	if (body.providerEnabled === false) return `Memory Space ${JSON.stringify(target)} uses ${body.provider.label}, which is turned off on the dsh-mnemon page under Plugins. Name another space.`;
+	if (body.provider.capabilities.remember !== true) return `Memory Space ${JSON.stringify(target)} (${body.provider.label}) does not take writes. Name another space.`;
+	if (!body.active && !activate) return `Memory Space ${JSON.stringify(target)} (${body.name}) is switched off, and a write would switch it back on. If the user wants it back, switch it on first with mnemon_memory_body_update (active: true); otherwise name an active space.`;
+}
+/** Whether a write receipt put the memory in its space, or handed it to a Provider that confirms later. */
 function writeLanded(value) {
 	if (mutationResultCommitted(value)) return true;
 	const state = [
@@ -10343,6 +10766,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 +10787,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 +10802,7 @@ var MnemonSubagentCoordinator = class {
 	}
 	dispose() {
 		this.disposed = true;
+		this.reviewAdmission.dispose();
 		this.resultRequests.clear();
 		const resumeGuard = this.disposeResumeGuard;
 		this.disposeResumeGuard = void 0;
@@ -10922,7 +11348,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 +11377,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 +11396,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 +11546,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, {
@@ -11276,7 +11752,7 @@ function bounded(value, maximum) {
 	if (typeof value !== "string") return void 0;
 	const normalized = value.replace(/\s+/gu, " ").trim();
 	if (normalized === "") return void 0;
-	return normalized.length <= maximum ? normalized : normalized.slice(0, maximum - 1) + "…";
+	return truncate(normalized, maximum);
 }
 function item(value, index) {
 	const entry = object$5(value);
@@ -11430,337 +11906,223 @@ function emptyActivity(turn) {
 /**
 * Incremental durable-log projection. Repeated UI reads process only events
 * appended since the previous snapshot instead of rescanning the full session.
-*/
-var TurnActivityProjection = class {
-	eventCount = 0;
-	lastEventSeq;
-	pending = /* @__PURE__ */ new Map();
-	byTurn = /* @__PURE__ */ new Map();
-	reset() {
-		this.eventCount = 0;
-		this.lastEventSeq = void 0;
-		this.pending.clear();
-		this.byTurn.clear();
-	}
-	snapshot(events) {
-		const currentLastSeq = events.at(-1)?.seq;
-		if (events.length < this.eventCount || events.length === this.eventCount && this.lastEventSeq !== currentLastSeq) this.reset();
-		for (let index = this.eventCount; index < events.length; index += 1) this.consume(events[index]);
-		this.eventCount = events.length;
-		this.lastEventSeq = currentLastSeq;
-		return {
-			cursor: typeof currentLastSeq === "number" ? currentLastSeq : events.length,
-			activities: [...this.byTurn.values()].sort((left, right) => left.turn - right.turn).map((activity) => ({
-				...activity,
-				names: [...activity.names],
-				retrieved: activity.retrieved.map((read) => ({
-					...read,
-					items: read.items.map((item) => ({ ...item }))
-				})),
-				writebacks: activity.writebacks.map((write) => ({
-					...write,
-					item: { ...write.item }
-				}))
-			}))
-		};
-	}
-	consume(event) {
-		if (event.type === "tool/call") {
-			const turn = eventTurn$1(event);
-			const callId = event.data.callId;
-			const name = event.data.name;
-			if (turn !== void 0 && typeof callId === "string" && typeof name === "string" && name.startsWith("mnemon_")) this.pending.set(callId, {
-				turn,
-				name
-			});
-			return;
-		}
-		if (event.type !== "tool/result") return;
-		const callId = resultCallId(event);
-		if (callId === void 0) return;
-		const call = this.pending.get(callId);
-		if (call === void 0) return;
-		this.pending.delete(callId);
-		let activity = this.byTurn.get(call.turn);
-		if (activity === void 0) {
-			activity = emptyActivity(call.turn);
-			this.byTurn.set(call.turn, activity);
-		}
-		activity.count += 1;
-		activity.names.push(call.name);
-		if (event.data.error !== void 0) {
-			activity.failures += 1;
-			return;
-		}
-		const semantic = parseMnemonActivityMeta(event.data.meta, callId, call.name);
-		if (semantic.read !== void 0) activity.retrieved.push(semantic.read);
-		if (semantic.writeback !== void 0) activity.writebacks.push(semantic.writeback);
-		const counted = counter(call.name);
-		if (counted !== void 0) activity[counted] += 1;
-	}
-};
-//#endregion
-//#region src/host/view-presentation.ts
-/**
-* The named tools bound to each Source type's Routes or Actions, from the tool table: these are
-* existing DSH product-tool bindings, not Core operation names. Tools that share one operation are
-* listed together, in table order, as the View's tool list names them.
-*/
-function namedBindings(kind) {
-	const bindings = {};
-	for (const [name, tool] of memoryTools()) {
-		if (tool.sourceTypeId === void 0 || tool.operation === void 0 || tool.kind === "write" !== (kind === "action")) continue;
-		const operations = bindings[tool.sourceTypeId] ??= {};
-		const listed = operations[tool.operation];
-		operations[tool.operation] = listed === void 0 ? name : `${listed} / ${name}`;
-	}
-	return bindings;
-}
-const ROUTE_TOOLS = namedBindings("route");
-const ACTION_TOOLS = namedBindings("action");
-const NAMED_SOURCE_TYPES = [.../* @__PURE__ */ new Set([...Object.keys(ROUTE_TOOLS), ...Object.keys(ACTION_TOOLS)])];
-/** Use a short availability list only where the Host has the matching named binding.
-* Unbound external operations retain exact ids and schemas in the generic envelope. */
-function modelMemoryWake(graph, turn) {
-	const generation = graph.memoryComposition.generation(turn.view.runtimeGeneration);
-	if (generation === void 0) throw new Error("Cannot present an unpinned Memory generation");
-	return graph.composableTurns.memoryWake(turn.view.id, memoryWakeBindings(generation, turn.view));
-}
-function presentMemoryWake(generation, view) {
-	return createMemoryWake(view, memoryWakeBindings(generation, view));
-}
-/**
-* Why a generic View tool names no id this turn's View offers, told apart (#390); undefined when
-* the id is offered. It names only what the MNEMON VIEW ROUTES envelope shows: an operation bound
-* to a named tool is offered through that tool, and the envelope does not list its id.
-*/
-function unofferedViewId(graph, turn, kind, id) {
-	const view = turn.view;
-	const offered = kind === "route" ? view.routes.map((route) => ({
-		id: route.id,
-		operation: route.sourceRouteId
-	})) : view.actionOffers.map((offer) => ({
-		id: offer.id,
-		operation: offer.sourceActionId
-	}));
-	const label = kind === "route" ? "memory View Route" : "memory ActionOffer";
-	if (typeof id !== "string" || id === "") return `${label} needs ${kind === "route" ? "routeId" : "offerId"}, the exact id of one it offers`;
-	if (offered.some((entry) => entry.id === id)) return void 0;
-	const generation = graph.memoryComposition.generation(view.runtimeGeneration);
-	const bindings = generation === void 0 ? {} : memoryWakeBindings(generation, view);
-	const named = (kind === "route" ? bindings.routes : bindings.actions) ?? {};
-	const short = id.split("/").at(-1);
-	const tools = [...new Set(offered.filter((entry) => named[entry.id] !== void 0 && (entry.operation === short || entry.id.split("/").at(-1) === short)).map((entry) => named[entry.id]))];
-	if (tools.length > 0) return `${label} is unavailable: ${id}; this View offers it as ${tools.join(" and ")}, so call that tool`;
-	const shown = offered.filter((entry) => named[entry.id] === void 0).map((entry) => entry.id);
-	if (shown.length === 0) return `${label} is unavailable: ${id}; MNEMON VIEW ROUTES offers none by id this turn, only the named tools in MNEMON VIEW TOOLS`;
-	const near = shown.filter((candidate) => candidate.split("/").at(-1) === short);
-	if (near.length === 1) return `${label} is unavailable: ${id}; ids are exact as MNEMON VIEW ROUTES lists them: ${JSON.stringify(near[0])}`;
-	const listed = [...near, ...shown.filter((candidate) => !near.includes(candidate))];
-	return `${label} is unavailable: ${id}; MNEMON VIEW ROUTES offers ${listed.slice(0, 12).map((candidate) => JSON.stringify(candidate)).join(", ")}${listed.length > 12 ? ` and ${listed.length - 12} more` : ""}`;
-}
-function memoryWakeBindings(generation, view) {
-	const instances = generation.sourceInstances();
-	const routes = {}, actions = {};
-	for (const typeId of NAMED_SOURCE_TYPES) {
-		const selected = namedToolInstance(instances.filter((source) => source.sourceTypeId === typeId), typeId);
-		if (selected === void 0) continue;
-		for (const route of view.routes.filter((route) => route.sourceInstanceKey === selected.sourceInstanceKey)) {
-			if (view.readGrants.find((grant) => grant.id === route.readGrantId)?.schema !== `dsh-mnemon.${typeId}/v1`) continue;
-			const tool = ROUTE_TOOLS[typeId]?.[route.sourceRouteId];
-			if (tool !== void 0) routes[route.id] = tool;
-		}
-		for (const action of view.actionOffers.filter((action) => action.sourceInstanceKey === selected.sourceInstanceKey)) {
-			const tool = ACTION_TOOLS[typeId]?.[action.sourceActionId];
-			if (tool !== void 0) actions[action.id] = tool;
-		}
-	}
-	return {
-		routes,
-		actions
-	};
-}
-/** Explicitly pick display fields; never copy grants, authority, or opaque Source state. */
-function inspectMemoryView(generation, view, state, turn, memoryText) {
-	return structuredClone({
-		id: view.id,
-		digest: view.digest,
-		generationId: view.runtimeGeneration,
-		createdAt: view.createdAt,
-		state,
-		...turn === void 0 ? {} : { turn },
-		strategyTypeId: view.strategyTypeId,
-		strategyInstanceKey: view.strategyInstanceKey,
-		extensions: view.strategyExtensions ?? [],
-		projection: view.projection.map(({ id, sourceInstanceKey, mode, text, revision }) => ({
-			id,
-			sourceInstanceKey,
-			mode,
-			text,
-			revision
-		})),
-		sourcePresentations: view.sourcePresentations ?? [],
-		routes: view.routes.map(({ id, sourceInstanceKey, sourceRouteId, description, maxCalls }) => ({
-			id,
-			sourceInstanceKey,
-			operationId: sourceRouteId,
-			description,
-			maxCalls
-		})),
-		actions: view.actionOffers.map(({ id, sourceInstanceKey, sourceActionId, description }) => ({
-			id,
-			sourceInstanceKey,
-			operationId: sourceActionId,
-			description
-		})),
-		memoryText: memoryText ?? presentMemoryWake(generation, view).text,
-		...view.guidance === void 0 ? {} : { guidance: view.guidance },
-		diagnostics: (view.diagnostics ?? []).map((diagnostic) => diagnostic.message)
-	});
-}
-//#endregion
-//#region src/host/agent-memory-turn.ts
-/** The durable log, not a parent session id, identifies the executing turn. */
-function openAgentTurn(agent) {
-	let open;
-	for (const event of agent.session.snapshotEvents()) {
-		const turn = typeof event.data.turn === "number" ? event.data.turn : void 0;
-		if (event.type === "turn/start" && turn !== void 0) open = turn;
-		else if (event.type === "turn/end" && turn === open) open = void 0;
-	}
-	return open;
-}
-/**
-* One Agent owns each turn pin. A child additionally retains its delegation
-* across parent completion, collection, and runtime swaps until it is disposed.
-*/
-var AgentMemoryTurn = class {
-	agent;
-	runtime;
-	delegation;
-	pinned;
-	/** A turn that runs without memory because no composition was serving when it began. */
-	unavailable;
-	warned;
-	pending;
-	generation = 0;
-	closed = false;
-	lastInspection;
-	lastWorkspace;
-	releaseDelegation;
-	constructor(agent, runtime, delegation) {
-		this.agent = agent;
-		this.runtime = runtime;
-		this.delegation = delegation;
-		if (delegation === void 0) return;
-		this.releaseDelegation = runtime.executions.retain(agent, delegation);
-	}
-	get current() {
-		return this.pinned;
-	}
-	/** Why the current turn has no View, when memory could not be composed for it. */
-	get unavailableReason() {
-		return this.unavailable?.reason;
-	}
-	inspect(workspaceRoot) {
-		if (this.lastInspection === void 0) return void 0;
-		if (workspaceRoot !== void 0 && resolve(workspaceRoot) !== this.lastWorkspace) return void 0;
-		return structuredClone({
-			...this.lastInspection,
-			state: this.pinned === void 0 ? "recent" : "active"
-		});
-	}
-	clearInspection() {
-		this.lastInspection = void 0;
-		this.lastWorkspace = void 0;
+*/
+var TurnActivityProjection = class {
+	eventCount = 0;
+	lastEventSeq;
+	pending = /* @__PURE__ */ new Map();
+	byTurn = /* @__PURE__ */ new Map();
+	reset() {
+		this.eventCount = 0;
+		this.lastEventSeq = void 0;
+		this.pending.clear();
+		this.byTurn.clear();
 	}
-	/** Capture now; descendants must not resolve a later parent turn on demand. */
-	delegate() {
-		if (this.closed) throw new Error("memory Agent lifetime has ended");
-		if (this.pinned !== void 0) return {
-			graph: this.pinned.graph,
-			scope: this.pinned.context.scope,
-			viewId: this.pinned.context.view.id
-		};
-		if (this.delegation !== void 0) return this.delegation;
-		const graph = this.runtime.forAgent(this.agent);
+	snapshot(events) {
+		const currentLastSeq = events.at(-1)?.seq;
+		if (events.length < this.eventCount || events.length === this.eventCount && this.lastEventSeq !== currentLastSeq) this.reset();
+		for (let index = this.eventCount; index < events.length; index += 1) this.consume(events[index]);
+		this.eventCount = events.length;
+		this.lastEventSeq = currentLastSeq;
 		return {
-			graph,
-			scope: agentScope(this.agent, graph.config)
+			cursor: typeof currentLastSeq === "number" ? currentLastSeq : events.length,
+			activities: [...this.byTurn.values()].sort((left, right) => left.turn - right.turn).map((activity) => ({
+				...activity,
+				names: [...activity.names],
+				retrieved: activity.retrieved.map((read) => ({
+					...read,
+					items: read.items.map((item) => ({ ...item }))
+				})),
+				writebacks: activity.writebacks.map((write) => ({
+					...write,
+					item: { ...write.item }
+				}))
+			}))
 		};
 	}
-	async begin(turn, signal) {
-		if (this.closed) throw new Error("memory Agent lifetime has ended");
-		signal?.throwIfAborted();
-		if (this.pinned?.turn === turn || this.unavailable?.turn === turn) return;
-		if (this.pending?.turn === turn) return this.pending.result;
-		this.end();
-		const generation = this.generation;
-		const controller = new AbortController();
-		const abort = () => controller.abort(signal.reason);
-		signal?.addEventListener("abort", abort, { once: true });
-		const result = this.pin(turn, generation, controller.signal).catch((error) => {
-			if (!isMemoryCompositionUnavailable(error) || this.closed || this.generation !== generation) throw error;
-			this.unavailable = {
+	consume(event) {
+		if (event.type === "tool/call") {
+			const turn = eventTurn$1(event);
+			const callId = event.data.callId;
+			const name = event.data.name;
+			if (turn !== void 0 && typeof callId === "string" && typeof name === "string" && name.startsWith("mnemon_")) this.pending.set(callId, {
 				turn,
-				reason: error.message
-			};
-			this.clearInspection();
-			if (this.warned !== error.message) console.warn(`[dsh-mnemon] this turn runs without memory: ${error.message}`);
-			this.warned = error.message;
-		});
-		this.pending = {
-			turn,
-			generation,
-			controller,
-			result
-		};
+				name
+			});
+			return;
+		}
+		if (event.type !== "tool/result") return;
+		const callId = resultCallId(event);
+		if (callId === void 0) return;
+		const call = this.pending.get(callId);
+		if (call === void 0) return;
+		this.pending.delete(callId);
+		let activity = this.byTurn.get(call.turn);
+		if (activity === void 0) {
+			activity = emptyActivity(call.turn);
+			this.byTurn.set(call.turn, activity);
+		}
+		activity.count += 1;
+		activity.names.push(call.name);
+		if (event.data.error !== void 0) {
+			activity.failures += 1;
+			return;
+		}
+		const semantic = parseMnemonActivityMeta(event.data.meta, callId, call.name);
+		if (semantic.read !== void 0) activity.retrieved.push(semantic.read);
+		if (semantic.writeback !== void 0) activity.writebacks.push(semantic.writeback);
+		const counted = counter(call.name);
+		if (counted !== void 0) activity[counted] += 1;
+	}
+};
+//#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 {
-			await result;
+			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 {
-			signal?.removeEventListener("abort", abort);
-			if (this.pending?.generation === generation) this.pending = void 0;
+			if (descriptor !== void 0) try {
+				fs.closeSync(descriptor);
+			} catch (error) {
+				throw failure$2(error);
+			}
 		}
 	}
-	end(turn) {
-		if (turn !== void 0 && this.pinned?.turn !== turn && this.pending?.turn !== turn && this.unavailable?.turn !== turn) return;
-		this.generation += 1;
-		this.unavailable = void 0;
-		this.pending?.controller.abort(/* @__PURE__ */ new Error("memory turn ended during View preparation"));
-		this.pending = void 0;
-		const pinned = this.pinned;
-		this.pinned = void 0;
-		pinned?.release();
+	/** 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;
+		});
 	}
-	dispose() {
-		if (this.closed) return;
-		this.closed = true;
-		this.clearInspection();
+	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 {
-			this.end();
+			fs.writeFileSync(temporary, JSON.stringify(state) + "\n", {
+				mode: 384,
+				flag: "wx"
+			});
+			fs.renameSync(temporary, this.path);
 		} finally {
-			this.releaseDelegation?.();
+			fs.rmSync(temporary, { force: true });
 		}
 	}
-	async pin(turn, generation, signal) {
-		const execution = await this.runtime.executions.turn(this.agent, turn, signal, this.delegation);
-		const { graph, context } = execution;
+	/**
+	* 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 {
-			if (this.closed || this.generation !== generation) throw new Error("memory turn ended during View preparation");
-			signal?.throwIfAborted();
-			const inspection = inspectMemoryView(graph.memoryComposition.generation(context.view.runtimeGeneration), context.view, "active", turn, modelMemoryWake(graph, context).text);
-			this.pinned = {
-				turn,
-				graph,
-				context,
-				release: execution.release
-			};
-			this.warned = void 0;
-			this.lastInspection = inspection;
-			this.lastWorkspace = context.scope.workspaceId === void 0 ? void 0 : resolve(context.scope.workspaceId);
+			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) {
-			execution.release();
-			throw error;
+			throw failure$2(error);
+		} finally {
+			if (held) try {
+				fs.rmdirSync(lock);
+			} catch (error) {
+				throw failure$2(error);
+			}
 		}
 	}
 };
@@ -11858,6 +12220,7 @@ var MnemonAgentLifecycle = class {
 	config;
 	counters;
 	memoryTurn;
+	runtimeDirectory;
 	primePending = true;
 	startSource;
 	guidedTurns = /* @__PURE__ */ new Set();
@@ -11874,10 +12237,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 +12259,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 +12278,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 +12297,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 },
@@ -11987,6 +12372,7 @@ var MnemonAgentLifecycle = class {
 			this.releaseView(payload.turn);
 			return decision;
 		}
+		if (!this.disposed && openAgentTurn(this.agent) === payload.turn) await this.memoryTurn?.begin(payload.turn, payload.signal);
 		if (!this.config.lifecycleEnabled) return decision;
 		if (this.config.writeEnabled && this.config.writebackMode === "guided") this.recordTurnMessages(payload.turn, decision.messages);
 		if (payload.step !== 1) return decision;
@@ -12030,7 +12416,35 @@ var MnemonAgentLifecycle = class {
 		this.memoryTurn?.end(turn);
 	}
 	async finishTurn(payload) {
-		this.scheduleIdleReview(payload.turn);
+		this.cancelIdleReview(true);
+		this.recordComposedTurn(payload.turn);
+		if (payload.signal.aborted || !this.restoreWatermark() || !this.idleReviewAllowed()) return;
+		const activity = this.ensureTurnActivity(payload.turn);
+		const tools = completedToolActivity(this.agent.session.snapshotEvents(), payload.turn);
+		activity.toolCallCount = tools.count;
+		activity.toolNames = tools.names;
+		if (!this.reviewActivity().eligible || !this.reviewAdmitted(payload.turn)) return;
+		const controller = new AbortController();
+		const signal = AbortSignal.any([payload.signal, controller.signal]);
+		const epoch = this.reviewEpoch;
+		const policy = this.reviewPolicy();
+		this.reviewController = controller;
+		this.reviewRunning = true;
+		let admitted = false;
+		try {
+			const available = await this.coordinator.checkReviewAccess(this.agent, signal);
+			if (signal.aborted || epoch !== this.reviewEpoch || policy !== this.reviewPolicy() || !this.idleReviewAllowed()) return;
+			this.reviewAccessBlocked = !available;
+			admitted = available;
+		} catch (error) {
+			if (!signal.aborted) this.fail(error);
+		} finally {
+			if (this.reviewController === controller) {
+				this.reviewRunning = false;
+				this.reviewController = void 0;
+			}
+		}
+		if (admitted) this.scheduleIdleReview(payload.turn);
 	}
 	sessionEvent(session, event) {
 		if (session !== this.agent.session || event.type !== "turn/end") return;
@@ -12041,16 +12455,13 @@ var MnemonAgentLifecycle = class {
 	}
 	scheduleIdleReview(turn) {
 		this.cancelIdleReview(true);
-		this.recordComposedTurn(turn);
-		if (!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.restoreWatermark() || !this.idleReviewAllowed()) return;
 		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 +12469,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 +12546,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 +12564,60 @@ 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);
+			if (epoch !== this.reviewEpoch || policy !== this.reviewPolicy() || !this.idleReviewAllowed()) controller.abort(/* @__PURE__ */ new Error("Automatic idle review admission changed"));
+			controller.signal.throwIfAborted();
+			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 +12638,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 +12802,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 +13315,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();
@@ -12857,7 +13381,21 @@ var MnemonLifecycle = class {
 				})));
 				stops.push(agent.ctx.on("agent/pre-step", (async (payload, next) => {
 					const decision = await next();
-					if (decision.kind === "reject" || payload.signal.aborted) memory.end(payload.turn);
+					if (decision.kind === "reject" || payload.signal.aborted) {
+						memory.end(payload.turn);
+						return decision;
+					}
+					if (openAgentTurn(agent) !== payload.turn) return decision;
+					const recovering = memory.current?.turn !== payload.turn;
+					await memory.begin(payload.turn, payload.signal);
+					const pinned = memory.current;
+					if (recovering && payload.step === 1 && this.config.lifecycleEnabled && pinned !== void 0) {
+						const wake = modelMemoryWake(pinned.graph, pinned.context);
+						if (wake.text.trim() !== "") return {
+							kind: "enter",
+							messages: [...decision.messages, createPluginMessage(wake.text, "recall")]
+						};
+					}
 					return decision;
 				})));
 				stops.push(agent.ctx.on("session/event", ((session, event) => {
@@ -13678,8 +14216,6 @@ var TrajectoryWindow = class {
 };
 //#endregion
 //#region src/host/skill-evolution.ts
-/** A new skill goes to the user's own DSH skills unless the page chose another root. */
-const DEFAULT_TARGET_ROOT = "user-dsh";
 /** A conversation's turn bars read at most this many of its reviews. */
 const ACTIVITY_REVIEWS = 50;
 const WAITING_STATUSES = /* @__PURE__ */ new Set([
@@ -13701,6 +14237,7 @@ const BACKTEST_CONCURRENCY = 2;
 */
 function retryingSource(source, attempts = 4) {
 	return {
+		...source.scope === void 0 ? {} : { scope: source.scope },
 		read: (operation, input, signal) => source.read(operation, input, signal),
 		mutate: async (operation, input, signal) => {
 			for (let attempt = 1;; attempt++) try {
@@ -13714,6 +14251,35 @@ function retryingSource(source, attempts = 4) {
 function message(error) {
 	return redact(error instanceof Error ? error.message : String(error));
 }
+/** Resolve only roots supplied by this Source's scoped catalog, never the task's cwd. */
+function newSkillRoot(settings, source, catalog, explicit) {
+	let root = explicit;
+	if (root === void 0) {
+		if (settings.targetScope === "storage" && source.scope === void 0) throw new Error("The skill destination needs a known storage scope; select User or Project in Skills settings.");
+		root = settings.targetScope === "project" || settings.targetScope === "storage" && (source.scope?.storage === "workspace" || source.scope?.storage === "workspaces") ? "project-dsh" : "user-dsh";
+	}
+	const directory = catalog.roots.find((candidate) => candidate.kind === root)?.path;
+	if (directory === void 0 || root.startsWith("project-") && catalog.projectRoot === void 0) throw new Error("Project skill roots need a selected workspace; select a workspace or choose User in Skills settings.");
+	if (root.startsWith("project-")) try {
+		if (!statSync(catalog.projectRoot).isDirectory()) throw new Error("not a directory");
+	} catch {
+		throw new Error("The selected workspace project is unavailable; select an existing workspace or choose User in Skills settings.");
+	}
+	let parent = directory;
+	try {
+		for (;;) try {
+			if (!statSync(parent).isDirectory()) throw new Error("not a directory");
+			accessSync(parent, constants.W_OK | constants.X_OK);
+			break;
+		} catch (error) {
+			if (error.code !== "ENOENT" || dirname(parent) === parent) throw error;
+			parent = dirname(parent);
+		}
+	} catch {
+		throw new Error(`Cannot create a skill in ${root}: its directory is not writable. Choose another destination or fix its permissions.`);
+	}
+	return root;
+}
 /**
 * The Host half of skill evolution: it captures each conversation's
 * trajectory as turns end, decides when a window has earned a review, runs
@@ -13893,7 +14459,8 @@ var SkillEvolution = class {
 			annotations: []
 		};
 		try {
-			const active = (await source.read("catalog", null, controller.signal)).skills.filter((skill) => skill.shadowedBy === void 0);
+			const catalog = await source.read("catalog", null, controller.signal);
+			const active = catalog.skills.filter((skill) => skill.shadowedBy === void 0);
 			const openSuggestions = [...await source.read("suggestions", { status: [
 				"pending",
 				"drafting",
@@ -13940,6 +14507,7 @@ var SkillEvolution = class {
 				expiryDays: current.expiryDays,
 				maxPendingPerSession: current.maxPendingPerSession
 			};
+			const targetRoot = policy.allowCreate && parsed.suggestions.some((suggestion) => suggestion.action === "create" && !active.some((skill) => skill.name === suggestion.skillName)) ? newSkillRoot(current, source, catalog) : void 0;
 			const result = await source.mutate("review-record", {
 				review: {
 					...base,
@@ -13949,7 +14517,10 @@ var SkillEvolution = class {
 				},
 				trajectory,
 				annotations: parsed.annotations,
-				suggestions: parsed.suggestions,
+				suggestions: parsed.suggestions.map((suggestion) => suggestion.action === "create" && targetRoot !== void 0 ? {
+					...suggestion,
+					targetRoot
+				} : suggestion),
 				cases: parsed.cases,
 				policy
 			});
@@ -13996,13 +14567,27 @@ var SkillEvolution = class {
 	*/
 	async draft(port, workspace, input) {
 		const source = retryingSource(port);
+		const pack = await source.read("evidence-pack", {
+			...input.suggestionId === void 0 ? {} : { suggestionId: input.suggestionId },
+			...input.skill === void 0 ? {} : { skill: input.skill }
+		});
+		const previous = pack.suggestion?.draftId === void 0 ? (await source.read("drafts", {
+			skill: pack.skillName,
+			...input.suggestionId === void 0 ? {} : { suggestionId: input.suggestionId }
+		})).find((draft) => draft.suggestionId === input.suggestionId) : (await source.read("draft", { id: pack.suggestion.draftId })).draft;
+		const targetRoot = pack.action === "update" ? pack.skill.root : newSkillRoot(this.host.settings(), source, await source.read("catalog"), input.targetRoot ?? previous?.targetRoot ?? pack.suggestion?.targetRoot);
+		const guidance = [...previous?.guidance ?? [], ...input.guidance?.trim() ? [input.guidance.trim()] : []].slice(-8);
 		if (input.suggestionId !== void 0) await source.mutate("suggestion-status", {
 			id: input.suggestionId,
 			status: "drafting"
 		});
 		this.background("skill draft", async (signal) => {
 			try {
-				await this.writeDraft(source, workspace, input, signal);
+				await this.writeDraft(source, workspace, input, {
+					pack,
+					targetRoot,
+					guidance
+				}, signal);
 			} catch (error) {
 				if (input.suggestionId !== void 0) await source.mutate("suggestion-status", {
 					id: input.suggestionId,
@@ -14017,14 +14602,9 @@ var SkillEvolution = class {
 			...input.suggestionId === void 0 ? {} : { suggestionId: input.suggestionId }
 		};
 	}
-	async writeDraft(source, workspace, input, signal) {
-		const pack = await source.read("evidence-pack", {
-			...input.suggestionId === void 0 ? {} : { suggestionId: input.suggestionId },
-			...input.skill === void 0 ? {} : { skill: input.skill }
-		}, signal);
+	async writeDraft(source, workspace, input, prepared, signal) {
 		const settings = this.host.settings();
-		const guidance = [...pack.drafts.find((draft) => input.suggestionId === void 0 ? draft.suggestionId === void 0 : draft.suggestionId === input.suggestionId)?.guidance ?? [], ...input.guidance?.trim() ? [input.guidance.trim()] : []].slice(-8);
-		const targetRoot = input.targetRoot ?? DEFAULT_TARGET_ROOT;
+		const { pack, targetRoot, guidance } = prepared;
 		let prompt = skillDraftPrompt(pack, guidance, targetRoot);
 		let draft;
 		for (let attempt = 0; draft === void 0; attempt++) {
@@ -15333,16 +15913,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 +18897,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) => {