dsh-mnemon 0.5.38 → 0.5.40

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-0u6dOiF9.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-DmL0It3P.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";
@@ -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.
 */
@@ -387,6 +387,7 @@ const DEFAULT_SKILLS_CONFIG = Object.freeze({
 	evolution: false,
 	allowCreate: true,
 	allowUpdate: true,
+	targetScope: "user",
 	autoBacktest: true,
 	hints: true,
 	sidebar: false,
@@ -474,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),
@@ -5331,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",
@@ -5340,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));
 		}
@@ -5373,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) {
@@ -6117,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 }
 		};
 	}
@@ -6279,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 },
@@ -7075,7 +7100,7 @@ var ComposableMemoryTurnManager = class {
 		const stored = this.requireTurn(turnId);
 		const operation = this.generations.acquire(stored.lease.id);
 		try {
-			return await operation.generation.executeAction(stored.context.view, offerId, input, authorize, signal);
+			return await operation.generation.executeAction(stored.context.view, offerId, input, authorize, signal, stored.context);
 		} finally {
 			operation.release();
 		}
@@ -10169,201 +10194,486 @@ async function assertAutomaticMemoryWrite(host, parent) {
 	return host.writableSourceFor(parent, "memory-spaces", "remember");
 }
 //#endregion
-//#region src/host/review-admission.ts
-const RESULT_TOOL = "mnemon_subagent_result";
-const CHECK_TIMEOUT_MS = 5e3;
-/** A no-op challenge through the same mandatory completion channel as review.
-* Inventory alone cannot see execution-time guards. No errors are classified as
-* permission failures, and an unavailable checkpoint is never a permanent ban.
+//#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.
 */
-var AutomaticReviewAdmission = class {
-	challenges = /* @__PURE__ */ new Map();
-	controllers = /* @__PURE__ */ new Set();
-	draining = /* @__PURE__ */ new WeakSet();
-	disposed = false;
-	/** Only an unexpired, host-issued challenge for this exact Agent can no-op. */
-	acknowledge(args, execution) {
-		if (typeof args !== "object" || args === null || !("requestId" in args) || typeof args.requestId !== "string") return false;
-		const challenge = this.challenges.get(args.requestId);
-		if (challenge === void 0 || challenge.agent !== execution.agent || challenge.execution !== void 0) return false;
-		execution.signal.throwIfAborted();
-		challenge.execution = execution;
-		return true;
-	}
-	dispose() {
-		this.disposed = true;
-		this.challenges.clear();
-		for (const controller of this.controllers) controller.abort();
-	}
-	async check(agent, signal) {
-		signal.throwIfAborted();
-		const tools = agent.ctx.tools;
-		if (this.disposed || tools?.execute === void 0 || this.draining.has(agent)) return false;
-		const controller = new AbortController();
-		this.controllers.add(controller);
-		const combined = AbortSignal.any([signal, controller.signal]);
-		const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
-		timeout.unref?.();
-		let rejectAbort;
-		const aborted = new Promise((_resolve, reject) => {
-			rejectAbort = () => reject(combined.reason);
-			combined.addEventListener("abort", rejectAbort, { once: true });
-		});
-		const attempt = async (codeMode) => {
-			combined.throwIfAborted();
-			const requestId = randomUUID();
-			const callId = randomUUID();
-			const challenge = {
-				agent,
-				accepted: false
-			};
-			this.challenges.set(requestId, challenge);
-			const stops = [];
-			let executing = false;
-			const cleanup = () => {
-				for (const stop of stops.reverse()) stop();
-				this.draining.delete(agent);
-			};
-			try {
-				stops.push(agent.ctx.on("tools/result", ((execution, result) => {
-					if (execution === challenge.execution) challenge.accepted = result.isError === false;
-				})));
-				stops.push(agent.ctx.on("tools/pre-execute", (async (execution, next) => {
-					const decision = await next();
-					return execution.agent === agent && (execution.callId === callId || execution.rootCallId === callId) && decision.kind === "ask" ? { kind: "cancel" } : decision;
-				}), { prepend: true }));
-				const args = {
-					requestId,
-					result: {}
-				};
-				const pending = tools.execute({
-					callId,
-					agent,
-					signal: combined,
-					name: codeMode ? "run_code" : RESULT_TOOL,
-					arguments: codeMode ? {
-						description: "Check automatic memory review availability",
-						code: `await tools.mnemon_subagent_result(${JSON.stringify(args)})`
-					} : args
-				});
-				executing = true;
-				this.draining.add(agent);
-				const settled = pending.finally(cleanup);
-				const outcome = await Promise.race([settled, aborted]);
-				combined.throwIfAborted();
-				return challenge.execution !== void 0 && challenge.accepted && outcome.isError === false;
-			} finally {
-				this.challenges.delete(requestId);
-				if (!executing) cleanup();
-			}
-		};
-		try {
-			if (await attempt(false)) return true;
-			return tools.get?.("run_code", agent) !== void 0 && await attempt(true);
-		} catch {
-			signal.throwIfAborted();
-			return false;
-		} finally {
-			clearTimeout(timeout);
-			if (rejectAbort !== void 0) combined.removeEventListener("abort", rejectAbort);
-			this.controllers.delete(controller);
-		}
+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}`;
 	}
-};
-//#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 }
-		};
-	});
+	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));
 }
 /**
-* 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.
+* 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.
 */
-const DELEGATED_TASK_PREFIX = "[dsh-mnemon:delegated ";
-function delegatedTaskLine(operation) {
-	return `${DELEGATED_TASK_PREFIX}${operation}]`;
+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` : ""}`;
 }
-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
+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;
 		}
-	},
-	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);
+	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;
+	}
+	/** 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 } : {},
@@ -11442,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);
@@ -11573,361 +11883,96 @@ function counter(name) {
 	return tool.sourceTypeId === "documents" ? "documentSearches" : "recalls";
 }
 function eventTurn$1(event) {
-	return typeof event.data.turn === "number" ? event.data.turn : void 0;
-}
-function resultCallId(event) {
-	const message = event.data.message;
-	return typeof message?.source?.callId === "string" && message.source.callId !== "" ? message.source.callId : void 0;
-}
-function emptyActivity(turn) {
-	return {
-		turn,
-		count: 0,
-		names: [],
-		recalls: 0,
-		writes: 0,
-		documentSearches: 0,
-		inspections: 0,
-		failures: 0,
-		retrieved: [],
-		writebacks: []
-	};
-}
-/**
-* 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)
-	});
+	return typeof event.data.turn === "number" ? event.data.turn : void 0;
 }
-//#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;
+function resultCallId(event) {
+	const message = event.data.message;
+	return typeof message?.source?.callId === "string" && message.source.callId !== "" ? message.source.callId : void 0;
+}
+function emptyActivity(turn) {
+	return {
+		turn,
+		count: 0,
+		names: [],
+		recalls: 0,
+		writes: 0,
+		documentSearches: 0,
+		inspections: 0,
+		failures: 0,
+		retrieved: [],
+		writebacks: []
+	};
 }
 /**
-* One Agent owns each turn pin. A child additionally retains its delegation
-* across parent completion, collection, and runtime swaps until it is disposed.
+* Incremental durable-log projection. Repeated UI reads process only events
+* appended since the previous snapshot instead of rescanning the full session.
 */
-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
-		};
-		try {
-			await result;
-		} finally {
-			signal?.removeEventListener("abort", abort);
-			if (this.pending?.generation === generation) this.pending = void 0;
+				name
+			});
+			return;
 		}
-	}
-	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?.();
+		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);
 		}
-	}
-	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;
+		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
@@ -12327,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;
@@ -12370,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;
@@ -12381,12 +12455,7 @@ var MnemonAgentLifecycle = class {
 	}
 	scheduleIdleReview(turn) {
 		this.cancelIdleReview(true);
-		this.recordComposedTurn(turn);
 		if (!this.restoreWatermark() || !this.idleReviewAllowed()) return;
-		const activity = this.ensureTurnActivity(turn);
-		const tools = completedToolActivity(this.agent.session.snapshotEvents(), turn);
-		activity.toolCallCount = tools.count;
-		activity.toolNames = tools.names;
 		if (!this.reviewActivity().eligible || !this.reviewAdmitted(turn)) return;
 		const epoch = this.reviewEpoch;
 		const policy = this.reviewPolicy();
@@ -12506,11 +12575,8 @@ var MnemonAgentLifecycle = class {
 		this.reviewRunning = true;
 		this.reviewController = controller;
 		try {
-			const available = await this.coordinator.checkReviewAccess(this.agent, controller.signal);
 			if (epoch !== this.reviewEpoch || policy !== this.reviewPolicy() || !this.idleReviewAllowed()) controller.abort(/* @__PURE__ */ new Error("Automatic idle review admission changed"));
 			controller.signal.throwIfAborted();
-			this.reviewAccessBlocked = !available;
-			if (!available) return;
 			if (this.config.idleReview.persistWatermark) try {
 				if (!this.restoreWatermark() || this.watermarkStore === void 0 || !this.idleReviewAllowed()) return;
 				const reserved = this.watermarkStore.reserve({
@@ -13315,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) => {
@@ -14136,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([
@@ -14159,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 {
@@ -14172,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
@@ -14351,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",
@@ -14398,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,
@@ -14407,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
 			});
@@ -14454,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,
@@ -14475,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++) {
@@ -14908,10 +15030,16 @@ async function catalog(runtime, lifecycle) {
 }
 async function compositionStatus(runtime) {
 	const composition = runtime.graph.memoryComposition.inspect();
-	const strategyTypeId = runtime.graph.memoryComposition.current()?.strategy.definition.manifest.typeId;
+	const strategy = runtime.graph.memoryComposition.current()?.strategy.definition.manifest;
 	return {
 		serving: composition.servingGenerationId !== void 0,
-		...strategyTypeId === void 0 ? {} : { strategyTypeId },
+		...strategy === void 0 ? {} : {
+			strategyTypeId: strategy.typeId,
+			workflows: {
+				idleReview: strategy.typeId === mainStrategyTypeId(runtime.graph.config) && strategyDrives(strategy, "idle-review"),
+				runtimeCapacity: strategyDrives(strategy, "runtime-capacity")
+			}
+		},
 		evaluation: composition.evaluation,
 		sources: (await catalog(runtime)).sources,
 		configuration: runtime.graph.config.memoryTopology