dsh-mnemon 0.5.42 → 0.5.44

package/lib/index.js

@@ -6,8 +6,8 @@ import { Context } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
 import { basename, delimiter, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { resolveEmbedding, resolvePersistenceStrategy, resolveRecallQuality } from "dsh-mnemon-source-memory-spaces";
-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 { CATEGORIES, DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, EDGE_TYPES, EMBEDDING_CREDENTIAL_PREFIX, 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, assertRuntimePinnedBudget, parseRuntimeBranches, runtimeBytes, runtimeProjection, summarizeRuntimeMemories } from "dsh-mnemon-source-runtime/contracts";
 import { createHash, randomUUID } from "node:crypto";
 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";
@@ -23,6 +23,8 @@ import { Agent, request as request$1 } from "node:https";
 import { connect } from "node:tls";
 import { readFile, stat } from "node:fs/promises";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import * as SkillsContracts from "dsh-mnemon-source-skills/contracts";
 import { z as z$1 } from "zod";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { isVolatile } from "@deepseek-ai/cosmokit";
@@ -389,6 +391,9 @@ const DEFAULT_SKILLS_CONFIG = Object.freeze({
 	allowUpdate: true,
 	targetScope: "user",
 	autoBacktest: true,
+	autoAdopt: false,
+	autoAdoptDailyLimit: 2,
+	autoAdoptTimeZone: "local",
 	draftMaxTokens: 32768,
 	draftRetryMaxTokens: 65536,
 	hints: true,
@@ -483,6 +488,18 @@ const SkillsConfig = z.object({
 		"project"
 	]).default(DEFAULT_SKILLS_CONFIG.targetScope),
 	autoBacktest: z.boolean().default(DEFAULT_SKILLS_CONFIG.autoBacktest),
+	autoAdopt: z.boolean().default(DEFAULT_SKILLS_CONFIG.autoAdopt),
+	autoAdoptDailyLimit: z.number().step(1).min(0).max(100).default(DEFAULT_SKILLS_CONFIG.autoAdoptDailyLimit),
+	autoAdoptTimeZone: z.transform(z.string(), (value) => {
+		if (value === "local") return value;
+		if (!value || value.length > 100) throw new Error("skills.autoAdoptTimeZone must be an IANA time zone or local");
+		try {
+			new Intl.DateTimeFormat("en", { timeZone: value }).format(0);
+		} catch {
+			throw new Error("skills.autoAdoptTimeZone must be an IANA time zone or local");
+		}
+		return value;
+	}).default(DEFAULT_SKILLS_CONFIG.autoAdoptTimeZone),
 	draftMaxTokens: z.number().step(1).min(128).max(131072).default(DEFAULT_SKILLS_CONFIG.draftMaxTokens),
 	draftRetryMaxTokens: z.number().step(1).min(128).max(131072).default(DEFAULT_SKILLS_CONFIG.draftRetryMaxTokens),
 	hints: z.boolean().default(DEFAULT_SKILLS_CONFIG.hints),
@@ -526,7 +543,9 @@ const MnemonEmbeddingSchema = z.object({
 	enabled: z.boolean().default(false),
 	endpoint: z.string().default(DEFAULT_EMBEDDING_ENDPOINT),
 	model: z.string().default(DEFAULT_EMBEDDING_MODEL),
-	apiKey: z.string().default(""),
+	apiKey: z.string().role("secret").default(""),
+	apiKeyEnv: z.string(),
+	apiKeyRef: z.string(),
 	protocol: z.union(MNEMON_EMBEDDING_PROTOCOLS).default(DEFAULT_EMBEDDING_PROTOCOL)
 });
 const RecallQualitySchema = z.object({
@@ -539,6 +558,7 @@ const RecallQualitySchema = z.object({
 	maxUnknownResults: z.number().step(1).min(0).max(50).default(DEFAULT_RECALL_MAX_UNKNOWN_RESULTS)
 });
 const RuntimeMemorySchema = z.object({
+	inheritToSubagents: z.boolean().default(false),
 	memoryLimitBytes: z.number().step(1).min(1).max(MAX_RUNTIME_MEMORY_LIMIT_BYTES).default(DEFAULT_RUNTIME_MEMORY_LIMIT_BYTES),
 	userLimitBytes: z.number().step(1).min(1).max(MAX_RUNTIME_MEMORY_LIMIT_BYTES).default(DEFAULT_RUNTIME_USER_LIMIT_BYTES),
 	maintenanceMaxTokens: z.number().step(1).min(1).max(MAX_RUNTIME_MAINTENANCE_MAX_TOKENS).default(DEFAULT_RUNTIME_MAINTENANCE_MAX_TOKENS)
@@ -595,6 +615,7 @@ const Config = z.object({
 	timeoutMs: z.number().step(1).min(100).max(12e4).default(DEFAULT_TIMEOUT_MS),
 	defaultRecallLimit: z.number().step(1).min(1).max(50).default(10),
 	runtimeMemory: RuntimeMemorySchema.default({
+		inheritToSubagents: false,
 		memoryLimitBytes: DEFAULT_RUNTIME_MEMORY_LIMIT_BYTES,
 		userLimitBytes: DEFAULT_RUNTIME_USER_LIMIT_BYTES,
 		maintenanceMaxTokens: DEFAULT_RUNTIME_MAINTENANCE_MAX_TOKENS
@@ -719,6 +740,8 @@ function resolveTaskAgentModel(value) {
 	};
 }
 function resolveRuntimeMemory(value) {
+	const inheritToSubagents = value?.inheritToSubagents ?? false;
+	if (typeof inheritToSubagents !== "boolean") throw new Error("dsh-mnemon: Runtime inheritToSubagents must be a boolean");
 	const memoryLimitBytes = value?.memoryLimitBytes ?? DEFAULT_RUNTIME_MEMORY_LIMIT_BYTES;
 	const userLimitBytes = value?.userLimitBytes ?? DEFAULT_RUNTIME_USER_LIMIT_BYTES;
 	const maintenanceMaxTokens = value?.maintenanceMaxTokens ?? 8192;
@@ -726,6 +749,7 @@ function resolveRuntimeMemory(value) {
 	if (!Number.isInteger(userLimitBytes) || userLimitBytes < 1 || userLimitBytes > MAX_RUNTIME_MEMORY_LIMIT_BYTES) throw new Error(`dsh-mnemon: Runtime USER.md limit must be an integer within 1..${MAX_RUNTIME_MEMORY_LIMIT_BYTES} bytes`);
 	if (!Number.isInteger(maintenanceMaxTokens) || maintenanceMaxTokens < 1 || maintenanceMaxTokens > 1e6) throw new Error(`dsh-mnemon: Runtime maintenance maxTokens must be an integer within 1..${MAX_RUNTIME_MAINTENANCE_MAX_TOKENS}`);
 	return {
+		inheritToSubagents,
 		memoryLimitBytes,
 		userLimitBytes,
 		maintenanceMaxTokens
@@ -2250,6 +2274,7 @@ function parseRuntime(value, limits = RUNTIME_MEMORY_LIMITS) {
 			"low"
 		].includes(String(entry.importance))) throw new Error("runtime memories.json contains an invalid entry");
 		if (typeof entry.created_at !== "string" || typeof entry.updated_at !== "string") throw new Error("runtime memories.json contains invalid timestamps");
+		if (entry.pinned !== void 0 && typeof entry.pinned !== "boolean") throw new Error("runtime memories.json contains invalid pin state");
 		const content = entry.content.trim().replace(/\s+/gu, " ");
 		if (content === "" || content.includes("§") || Buffer.byteLength(content, "utf8") > RUNTIME_ENTRY_MAX_BYTES) throw new Error("runtime memories.json contains invalid content");
 		const branches = entry.target === "memory" ? parseRuntimeBranches(entry.branches) : void 0;
@@ -2260,10 +2285,12 @@ function parseRuntime(value, limits = RUNTIME_MEMORY_LIMITS) {
 			importance: entry.importance,
 			created_at: entry.created_at,
 			updated_at: entry.updated_at,
+			...entry.pinned === void 0 ? {} : { pinned: entry.pinned },
 			...branches === void 0 ? {} : { branches },
 			...origin === void 0 ? {} : { origin }
 		};
 	});
+	assertRuntimePinnedBudget(entries);
 	for (const target of ["user", "memory"]) {
 		const used = runtimeBytes(entries, target);
 		if (used > limits[target]) throw new Error(`runtime ${target} memory holds ${used} bytes and exceeds its ${limits[target]} byte limit`);
@@ -2476,6 +2503,7 @@ function archiveRuntimeOverflow(stagedRuntime, entries) {
 }
 /** Retain the same hot set on both machines, without asking a model to rewrite evidence. */
 function fitMergedRuntime(entries, limits) {
+	if (runtimeBytes(entries.filter((entry) => entry.pinned === true), "memory") > limits.memory) throw new Error("Pinned runtime entries exceed the merge capacity. Unpin entries or increase the capacity; no data was changed.");
 	if (runtimeBytes(entries, "memory") <= limits.memory) return {
 		entries,
 		archived: []
@@ -2486,7 +2514,7 @@ function fitMergedRuntime(entries, limits) {
 		low: 0
 	};
 	const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
-	const ranked = entries.filter((entry) => entry.target === "memory").sort((left, right) => importance[right.importance] - importance[left.importance] || compare(right.updated_at, left.updated_at) || compare(entryKey(left), entryKey(right)));
+	const ranked = entries.filter((entry) => entry.target === "memory").sort((left, right) => Number(right.pinned === true) - Number(left.pinned === true) || importance[right.importance] - importance[left.importance] || compare(right.updated_at, left.updated_at) || compare(entryKey(left), entryKey(right)));
 	const kept = [];
 	const archived = [];
 	for (const entry of ranked) if (runtimeBytes([...kept, entry], "memory") <= limits.memory) kept.push(entry);
@@ -2835,7 +2863,14 @@ function mergeRuntime(root, pack, runtimeLimits, options = {}) {
 			}
 			for (const tombstone of hidden) if (!revived.includes(tombstone)) revived.push(tombstone);
 		}
-		if (keys.has(key)) continue;
+		if (keys.has(key)) {
+			const existing = entries.find((candidate) => entryKey(candidate) === key);
+			if (entry.pinned !== void 0 && (existing.pinned === void 0 || entry.updated_at > existing.updated_at)) {
+				existing.pinned = entry.pinned;
+				if (entry.updated_at > existing.updated_at) existing.updated_at = entry.updated_at;
+			}
+			continue;
+		}
 		keys.add(key);
 		entries.push(entry);
 		incomingKeys.add(key);
@@ -3560,6 +3595,44 @@ var MnemonReviewLedger = class {
 	}
 };
 //#endregion
+//#region src/host/disposable-directory.ts
+function makeWritable(path) {
+	let entry;
+	try {
+		entry = lstatSync(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	if (entry.isSymbolicLink()) return;
+	if ((entry.mode & 128) === 0) chmodSync(path, entry.mode | 128);
+	if (entry.isDirectory()) for (const name of readdirSync(path)) makeWritable(join(path, name));
+}
+/** Remove only a caller-owned disposable tree, including read-only Git packs on Windows. */
+function removeDisposableDirectory(path) {
+	try {
+		rmSync(path, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		const code = error.code;
+		if (process.platform !== "win32" || ![
+			"EPERM",
+			"EACCES",
+			"ENOTEMPTY",
+			"EBUSY"
+		].includes(code ?? "")) throw error;
+		makeWritable(path);
+		rmSync(path, {
+			recursive: true,
+			force: true,
+			maxRetries: 3,
+			retryDelay: 100
+		});
+	}
+}
+//#endregion
 //#region src/host/github-transport.ts
 /**
 * How GitHub sign-in reaches GitHub.
@@ -4598,10 +4671,7 @@ var MnemonSyncSettingsStore = class {
 		};
 	}
 	clearMirror() {
-		rmSync(this.mirror(), {
-			recursive: true,
-			force: true
-		});
+		removeDisposableDirectory(this.mirror());
 	}
 };
 //#endregion
@@ -5983,16 +6053,10 @@ var MnemonGitSync = class {
 				cwd: mirror,
 				signal
 			});
-			if (origin.exitCode !== 0 || origin.stdout.trim() !== settings.repoUrl) rmSync(mirror, {
-				recursive: true,
-				force: true
-			});
+			if (origin.exitCode !== 0 || origin.stdout.trim() !== settings.repoUrl) removeDisposableDirectory(mirror);
 		}
 		if (!existsSync(join(mirror, ".git"))) {
-			rmSync(mirror, {
-				recursive: true,
-				force: true
-			});
+			removeDisposableDirectory(mirror);
 			const initialized = await this.git([
 				"init",
 				"--quiet",
@@ -6119,10 +6183,7 @@ var MnemonGitSync = class {
 		const root = this.payloadRoot(subdir);
 		const mirror = resolve(this.store.mirror());
 		if (root === mirror || !root.startsWith(mirror + (process.platform === "win32" ? "\\" : "/"))) throw new Error("sync directory escapes the mirror");
-		rmSync(root, {
-			recursive: true,
-			force: true
-		});
+		removeDisposableDirectory(root);
 		for (const [path, bytes] of Object.entries(entries)) {
 			const file = resolve(root, path);
 			mkdirSync(join(file, ".."), {
@@ -9456,7 +9517,7 @@ const WRITE_TOOL_FALLBACK_ACTION = {
 };
 function reviewReceipt(receipt) {
 	if (!mutationResultCommitted(receipt.value)) return void 0;
-	const value = object$6(receipt.value);
+	const value = object$7(receipt.value);
 	const args = optionalObject(receipt.arguments);
 	const document = optionalObject(value.document);
 	return {
@@ -9467,7 +9528,7 @@ function reviewReceipt(receipt) {
 		...typeof value.revision === "string" ? { revision: value.revision } : {}
 	};
 }
-function object$6(value) {
+function object$7(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("memory subagent returned an invalid structured result");
 	return value;
 }
@@ -9672,7 +9733,11 @@ function runtimeRouteChunks(entries) {
 function compactedBudget(plan) {
 	const pendingBytes = plan.pending === void 0 ? 0 : Buffer.byteLength(plan.pending.content, "utf8");
 	const separatorBytes = plan.pending === void 0 || plan.entries.length === 0 ? 0 : Buffer.byteLength(RUNTIME_ENTRY_DELIMITER, "utf8");
-	return Math.max(0, Math.floor(plan.limit * .7) - pendingBytes - separatorBytes);
+	const pinned = plan.entries.filter((entry) => entry.pinned === true);
+	const pinnedBytes = Buffer.byteLength(pinned.map((entry) => entry.content).join(RUNTIME_ENTRY_DELIMITER), "utf8");
+	const available = plan.limit - pendingBytes - separatorBytes;
+	if ((pinned.length > 0 || plan.pending?.pinned === true) && pinnedBytes > available) throw new Error("Pinned runtime entries leave no capacity for this write. Unpin entries or increase the capacity; no archive writes were attempted.");
+	return Math.max(pinnedBytes, Math.max(0, Math.floor(plan.limit * .7) - pendingBytes - separatorBytes));
 }
 function runtimeMigrationSources(revision, entries) {
 	return entries.map((entry, offset) => ({
@@ -9703,7 +9768,7 @@ async function runtimeArchiveSource(runtimeSource, graph, scope, view, generatio
 	return {
 		source,
 		cleanup,
-		memoryBodyIds: new Set(strings(object$6(grant.value).memoryBodyIds)),
+		memoryBodyIds: new Set(strings(object$7(grant.value).memoryBodyIds)),
 		writeScope: {
 			viewId: view.id,
 			grant
@@ -9721,10 +9786,11 @@ async function archiveRuntimeLocally(counters, context, request, plan, reason, s
 	if (plan.localArchive !== true) throw new Error(`runtime memory archival found no Memory Space that can take the archive (${reason}), and this Runtime Source cannot archive locally; pending write was not committed and existing runtime entries are unchanged; update dsh-mnemon-source-runtime, activate a supported Memory Space, or increase runtimeMemory.memoryLimitBytes`);
 	context.assertWritable?.();
 	const runId = `host-${randomUUID()}`;
-	const compacted = plan.entries.map(({ content, importance, branches }) => ({
+	const compacted = plan.entries.map(({ content, importance, branches, pinned }) => ({
 		content,
 		importance,
-		...branches === void 0 ? {} : { branches }
+		...branches === void 0 ? {} : { branches },
+		...pinned === void 0 ? {} : { pinned }
 	}));
 	const mutation = await context.runtime.mutateResult("compact-and-mutate", {
 		revision: plan.revision,
@@ -9767,7 +9833,9 @@ async function runtimeLocked(counters, context, request, signal) {
 	if (context.expectedRevision !== void 0 && context.expectedRevision !== plan.revision) throw new Error("Runtime source revision conflict before capacity maintenance");
 	if (!plan.requiresMaintenance) return context.commit();
 	if (plan.entries.length === 0) throw new Error("runtime memory capacity was exceeded without entries available for maintenance");
+	compactedBudget(plan);
 	if (request.target === "user") return compactUserAndCommit(context, request, plan, signal);
+	const archiveEntries = plan.entries.filter((entry) => entry.pinned !== true);
 	const archive = await context.memorySpaces();
 	if (archive === void 0) return archiveRuntimeLocally(counters, context, request, plan, "no Memory Space takes automatic writes here", signal);
 	const memoryService = archive.source;
@@ -9802,11 +9870,11 @@ async function runtimeLocked(counters, context, request, signal) {
 	let provider = "host";
 	let runId = `host-${randomUUID()}`;
 	let summary = "Routed every entry to the only eligible Memory Space without model work.";
-	if (eligibleBodies.length === 1) for (const index of plan.entries.keys()) routed.set(index + 1, eligibleBodies[0].id);
+	if (eligibleBodies.length === 1) for (const index of archiveEntries.keys()) routed.set(index + 1, eligibleBodies[0].id);
 	else {
 		const summaries = [];
 		const fallbackBody = eligibleBodies.find((body) => body.mnemonDefault) ?? eligibleBodies[0];
-		const chunks = runtimeRouteChunks(plan.entries);
+		const chunks = runtimeRouteChunks(archiveEntries);
 		for (const [chunkIndex, chunk] of chunks.entries()) {
 			const prompt = `Route this bounded MEMORY.md archive batch now. The host retains and writes the exact source content; these excerpts exist only for destination selection.
 
@@ -9825,13 +9893,13 @@ ${chunk.context}
 					provider = delegated.provider;
 					runId = delegated.runId;
 				}
-				const value = object$6(delegated.result.structured);
+				const value = object$7(delegated.result.structured);
 				if (value.action !== "planned") throw new Error(typeof value.summary === "string" && value.summary !== "" ? value.summary : "runtime memory archival routing failed");
 				if (!Array.isArray(value.routes) || value.routes.length === 0) throw new Error("runtime memory migration returned no routes");
 				const allowedIndexes = new Set(chunk.indexes);
 				const proposed = /* @__PURE__ */ new Map();
 				for (const candidate of value.routes) {
-					const route = object$6(candidate);
+					const route = object$7(candidate);
 					const memoryBodyId = typeof route.memoryBodyId === "string" ? route.memoryBodyId.trim() : "";
 					if (memoryBodyId === "" || !eligibleById.has(memoryBodyId)) throw new Error(`runtime memory migration selected an invalid Memory Space: ${memoryBodyId || "(empty)"}`);
 					if (!Array.isArray(route.sourceIndexes) || route.sourceIndexes.length === 0) throw new Error("runtime memory migration route must contain source indexes");
@@ -9851,11 +9919,12 @@ ${chunk.context}
 		}
 		summary = summaries.join(" ");
 	}
-	if (routed.size !== plan.entries.length) throw new Error("runtime memory migration omitted committed archive sources");
-	const compactedEntries = plan.entries.map(({ content, importance, branches }) => ({
+	if (routed.size !== archiveEntries.length) throw new Error("runtime memory migration omitted committed archive sources");
+	const compactedEntries = plan.entries.map(({ content, importance, branches, pinned }) => ({
 		content,
 		importance,
-		...branches === void 0 ? {} : { branches }
+		...branches === void 0 ? {} : { branches },
+		...pinned === void 0 ? {} : { pinned }
 	}));
 	if ((await runtimeMemory.read("maintenance-plan", {
 		...request,
@@ -9865,9 +9934,9 @@ ${chunk.context}
 	for (const memoryBodyId of new Set(routed.values())) if (!destinations.items.some((body) => body.id === memoryBodyId && eligible(body))) throw new Error(`runtime archive Memory Space ${memoryBodyId} is no longer eligible; no archive writes were attempted`);
 	signal.throwIfAborted();
 	context.assertWritable?.();
-	const sources = runtimeMigrationSources(plan.revision, plan.entries);
+	const sources = runtimeMigrationSources(plan.revision, archiveEntries);
 	const requests = sources.map((source) => {
-		const entry = plan.entries[source.index - 1];
+		const entry = archiveEntries[source.index - 1];
 		return {
 			content: entry.content,
 			category: "context",
@@ -9910,7 +9979,7 @@ ${chunk.context}
 				archiveResults.set(source.index, result);
 			}
 			if (written.length !== batch.length) throw new Error("runtime archive batch did not return one receipt per source entry");
-			for (const source of batch) verified.set(source.index, await archiveRuntimeEntry(memoryService, memoryBodyId, plan.entries[source.index - 1], archiveResults.get(source.index), signal));
+			for (const source of batch) verified.set(source.index, await archiveRuntimeEntry(memoryService, memoryBodyId, archiveEntries[source.index - 1], archiveResults.get(source.index), signal));
 		}
 		const lineage = [];
 		const memoryBodyIds = /* @__PURE__ */ new Set();
@@ -9977,16 +10046,18 @@ ${chunk.context}
 async function compactUserAndCommit(context, request, plan, signal) {
 	const runtimeMemory = context.runtime;
 	const budget = compactedBudget(plan);
+	const pinned = plan.entries.filter((entry) => entry.pinned === true);
+	const mutable = plan.entries.filter((entry) => entry.pinned !== true);
 	const prompt = `Run local USER.md compaction now.
 Pending mutation (uncommitted; do not include in compaction):
 ${pendingMutationContext(plan)}
 
-${runtimeSnapshotContext("user", plan.entries)}`;
+${runtimeSnapshotContext("user", mutable)}`;
 	const { provider, runId, result } = await context.model("compaction", "Consolidate local user profile", prompt, USER_COMPACTION_SCHEMA, USER_COMPACTION_PERSONA);
-	const value = object$6(result.structured);
+	const value = object$7(result.structured);
 	if (value.action !== "compacted") throw new Error(typeof value.summary === "string" && value.summary !== "" ? value.summary : "USER.md compaction failed");
 	const compactedEntries = Array.isArray(value.compactedEntries) ? value.compactedEntries.map((entry) => {
-		const item = object$6(entry);
+		const item = object$7(entry);
 		if (typeof item.content !== "string" || ![
 			"critical",
 			"normal",
@@ -10010,17 +10081,21 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 		if (entry.sourceIndexes.length === 0) throw new Error("USER.md compaction returned an entry without a source");
 		let requiredRank = 0;
 		for (const index of entry.sourceIndexes) {
-			if (index < 1 || index > plan.entries.length || seen.has(index)) throw new Error("USER.md compaction source coverage is invalid");
+			if (index < 1 || index > mutable.length || seen.has(index)) throw new Error("USER.md compaction source coverage is invalid");
 			seen.add(index);
-			requiredRank = Math.max(requiredRank, importanceRank[plan.entries[index - 1].importance]);
+			requiredRank = Math.max(requiredRank, importanceRank[mutable[index - 1].importance]);
 		}
 		if (importanceRank[entry.importance] < requiredRank) throw new Error("USER.md compaction lowered source importance");
 	}
-	if (seen.size !== plan.entries.length) throw new Error("USER.md compaction omitted committed entries");
-	const candidates = compactedEntries.map(({ content, importance }) => ({
+	if (seen.size !== mutable.length) throw new Error("USER.md compaction omitted committed entries");
+	const candidates = [...pinned.map((entry) => ({
+		content: entry.content,
+		importance: entry.importance,
+		pinned: true
+	})), ...compactedEntries.map(({ content, importance }) => ({
 		content,
 		importance
-	}));
+	}))];
 	const candidateBytes = Buffer.byteLength(candidates.map((entry) => entry.content.trim().replace(/\s+/gu, " ")).join(RUNTIME_ENTRY_DELIMITER), "utf8");
 	if (candidateBytes > budget) throw new Error(`USER.md compaction did not fit the host budget (${candidateBytes} > ${budget} bytes)`);
 	signal.throwIfAborted();
@@ -10160,7 +10235,7 @@ async function archiveDocumentLocked(host, parent, id, signal) {
 		const cleanup = graph.source("memory-spaces", agentScope(parent, graph.config)).forInstance(identity.sourceInstanceKey).forGeneration(lease.generation);
 		const grant = authority?.context.view.readGrants.find((grant) => grant.sourceInstanceKey === identity.sourceInstanceKey && grant.schema === "dsh-mnemon.memory-spaces/v1");
 		if (authority !== void 0 && grant === void 0) throw new Error("document archive requires a Memory Space namespace grant");
-		const allowed = grant === void 0 ? void 0 : new Set(strings(object$6(grant.value).memoryBodyIds));
+		const allowed = grant === void 0 ? void 0 : new Set(strings(object$7(grant.value).memoryBodyIds));
 		const directory = await memoryService.read("body-directory", null, signal);
 		const indexable = (body) => archivableSpace(directory, body);
 		const eligible = (body) => indexable(body) && (allowed === void 0 || allowed.has(body.id));
@@ -10170,7 +10245,7 @@ async function archiveDocumentLocked(host, parent, id, signal) {
 			throw new Error("document archive requires an existing active Memory Space with exact writes and safe forget");
 		}
 		const { provider, runId, result } = await host.delegate(parent, "document-archive", "Plan managed document archive", documentArchivePrompt(document, source, bodies), [], DOCUMENT_ARCHIVE_SCHEMA, signal, "spawn", DOCUMENT_ARCHIVE_PERSONA);
-		const value = object$6(result.structured);
+		const value = object$7(result.structured);
 		const summary = typeof value.summary === "string" ? value.summary.trim() : "";
 		if (value.action !== "planned") throw new Error(summary || "document archive planning failed");
 		if (summary === "" || summary.length > 1e3) throw new Error("document archive summary must contain 1–1000 characters");
@@ -10357,9 +10432,16 @@ 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) {
+function modelMemoryWake(graph, turn, includeRuntime = true) {
 	const generation = graph.memoryComposition.generation(turn.view.runtimeGeneration);
 	if (generation === void 0) throw new Error("Cannot present an unpinned Memory generation");
+	if (!includeRuntime) {
+		const runtimeSources = new Set(generation.sourceInstances().filter((source) => source.sourceTypeId === "runtime").map((source) => source.sourceInstanceKey));
+		return createMemoryWake({
+			...turn.view,
+			projection: turn.view.projection.filter((fragment) => !runtimeSources.has(fragment.sourceInstanceKey))
+		}, memoryWakeBindings(generation, turn.view));
+	}
 	return graph.composableTurns.memoryWake(turn.view.id, memoryWakeBindings(generation, turn.view));
 }
 function presentMemoryWake(generation, view) {
@@ -10466,6 +10548,23 @@ function openAgentTurn(agent) {
 	}
 	return open;
 }
+/** PTC dispatch records belong to a real open step, not just an open turn. */
+function openAgentStep(agent) {
+	let turn;
+	let open;
+	for (const event of agent.session.snapshotEvents()) if (event.type === "turn/start") {
+		turn = typeof event.data.turn === "number" ? event.data.turn : void 0;
+		open = void 0;
+	} else if (event.type === "turn/end" && event.data.turn === turn) {
+		turn = void 0;
+		open = void 0;
+	} else if (event.type === "step/start" && turn !== void 0 && event.data.turn === turn && typeof event.data.step === "number") open = {
+		turn,
+		step: event.data.step
+	};
+	else if (event.type === "step/end" && open?.turn === event.data.turn && open?.step === event.data.step) 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.
@@ -10485,17 +10584,23 @@ var AgentMemoryTurn = class {
 	lastInspection;
 	lastWorkspace;
 	releaseDelegation;
+	includeRuntime;
 	constructor(agent, runtime, delegation, independent = false) {
 		this.agent = agent;
 		this.runtime = runtime;
 		this.delegation = delegation;
 		this.independent = independent;
+		this.includeRuntime = delegation === void 0 || runtime.config.runtimeMemory.inheritToSubagents;
 		if (delegation === void 0) return;
 		this.releaseDelegation = runtime.executions.retain(agent, delegation);
 	}
 	get current() {
 		return this.pinned;
 	}
+	modelWake() {
+		const pinned = this.pinned;
+		return pinned === void 0 ? void 0 : modelMemoryWake(pinned.graph, pinned.context, this.includeRuntime);
+	}
 	/** Why the current turn has no View, when memory could not be composed for it. */
 	get unavailableReason() {
 		return this.unavailable?.reason;
@@ -10586,7 +10691,7 @@ var AgentMemoryTurn = class {
 		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);
+			const inspection = inspectMemoryView(graph.memoryComposition.generation(context.view.runtimeGeneration), context.view, "active", turn, modelMemoryWake(graph, context, this.includeRuntime).text);
 			this.pinned = {
 				turn,
 				graph,
@@ -10630,7 +10735,7 @@ async function executeHostTool(tools, input) {
 //#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.
+/** An in-step 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.
 */
@@ -10656,7 +10761,7 @@ var AutomaticReviewAdmission = class {
 	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;
+		if (this.disposed || tools?.execute === void 0 || this.draining.has(agent) || openAgentStep(agent) === void 0) return false;
 		const controller = new AbortController();
 		this.controllers.add(controller);
 		const combined = AbortSignal.any([signal, controller.signal]);
@@ -11069,7 +11174,7 @@ var MnemonSubagentCoordinator = class {
 				if (!isSubagent(execution.agent)) throw new Error("Mnemon subagent result tools are restricted to delegated children");
 				execution.signal.throwIfAborted();
 				assertDshOutputValue(RESULT_TOOL_INPUT_SCHEMA, args);
-				const request = object$6(args);
+				const request = object$7(args);
 				const submit = this.resultRequests.get(String(request.requestId));
 				if (this.disposed || submit === void 0) throw new Error("Mnemon subagent result request is unknown or no longer active");
 				return submit(request.result, execution);
@@ -11306,7 +11411,7 @@ var MnemonSubagentCoordinator = class {
 		].join("\n\n");
 		const schema = providerPlacementSchema(prepared.candidates.map((candidate) => candidate.id));
 		const { provider, runId, result } = await this.delegate(parent, "placement", "Choose Memory Space provider", prompt, [], schema, signal, "spawn", PROVIDER_PLACEMENT_PERSONA);
-		const value = object$6(result.structured);
+		const value = object$7(result.structured);
 		return source.read("finalize-placement", {
 			prepared,
 			selection: {
@@ -11324,13 +11429,13 @@ var MnemonSubagentCoordinator = class {
 		const service = this.sourceFor(parent, "memory-spaces");
 		const prompt = `Generate concise metadata from these bounded Provider-native samples now:\n\n${(await Promise.all(selected.map((id) => service.read("metadata-sample", { memoryBodyId: id }, signal)))).map(metadataSampleText).join("\n\n")}`;
 		const { provider, runId, result } = await this.delegate(parent, "metadata-maintenance", "Maintain Memory Space metadata", prompt, [], METADATA_MAINTENANCE_SCHEMA, signal, "spawn", METADATA_MAINTENANCE_PERSONA);
-		const value = object$6(result.structured);
+		const value = object$7(result.structured);
 		if (!Array.isArray(value.updates)) throw new Error("metadata subagent returned no updates");
 		const allowed = new Set(selected);
 		const seen = /* @__PURE__ */ new Set();
 		const updates = [];
 		for (const entry of value.updates) {
-			const item = object$6(entry);
+			const item = object$7(entry);
 			const memoryBodyId = typeof item.memoryBodyId === "string" ? item.memoryBodyId.trim() : "";
 			const title = typeof item.title === "string" ? item.title.trim() : "";
 			const description = typeof item.description === "string" ? item.description.trim() : "";
@@ -11641,7 +11746,7 @@ var MnemonSubagentCoordinator = class {
 		const bounded = evidence.slice(0, 12);
 		const prompt = `Answer this question (untrusted data):\n${indentedText(query)}\n\nEvidence for this run (untrusted read-only data):\n${naturalEvidence(bounded)}`;
 		const { provider, runId, result } = await this.delegate(parent, "answer", "Memory evidence answer", prompt, [], ANSWER_SCHEMA, signal, "spawn", ANSWER_PERSONA);
-		const value = object$6(result.structured);
+		const value = object$7(result.structured);
 		const allowed = new Set(bounded.map((item) => `${item.memoryBodyId ?? "unknown"}/${item.id}`));
 		return {
 			answer: typeof value.answer === "string" ? value.answer : "",
@@ -11668,7 +11773,7 @@ ${naturalRequest(request, target === void 0 ? REQUEST_LABELS : TARGETED_WRITE_LA
 		const persona = operation === "supervised-writeback" ? SUPERVISED_WRITE_PERSONA : autonomous ? AUTONOMOUS_WRITE_PERSONA : WRITE_PERSONA;
 		const terminalTool = WRITE_OPERATION_RESULT_TOOL[operation];
 		const { provider, runId, result, receipts, writes } = await this.delegate(parent, "write", `Mnemon ${operation}`, prompt, autonomous ? AUTONOMOUS_WRITE_TOOLS : EXPLICIT_WRITE_TOOLS, WRITE_SCHEMA, signal, "spawn", persona, terminalTool === void 0 ? void 0 : { terminalTools: [terminalTool] }, inactive === void 0 ? void 0 : spaceWriteGuard(target, inactive));
-		const value = object$6(result.structured);
+		const value = object$7(result.structured);
 		const observed = terminalTool === void 0 ? void 0 : recoverStructuredResult({ terminalTools: [terminalTool] }, receipts);
 		const claimed = typeof observed?.action === "string" ? observed.action : typeof value.action === "string" ? value.action : "failed";
 		if (!autonomous) return {
@@ -11777,7 +11882,7 @@ ${naturalRequest(request, target === void 0 ? REQUEST_LABELS : TARGETED_WRITE_LA
 			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);
+			const value = object$7(result.structured);
 			return {
 				delegated: true,
 				runId,
@@ -11948,7 +12053,7 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 				"failed",
 				"partial",
 				"unknown"
-			].includes(String(object$6(structured).action))) throw new Error(`memory review reported ${object$6(structured).action}`);
+			].includes(String(object$7(structured).action))) throw new Error(`memory review reported ${object$7(structured).action}`);
 			completed = {
 				provider,
 				runId: activeRun.id,
@@ -12111,7 +12216,7 @@ const MNEMON_ACTIVITY_SCHEMA = "dsh-mnemon.activity/v1";
 const MAX_ITEMS = 8;
 const MAX_TITLE = 160;
 const MAX_EXCERPT = 500;
-function object$5(value) {
+function object$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function bounded(value, maximum) {
@@ -12121,7 +12226,7 @@ function bounded(value, maximum) {
 	return truncate(normalized, maximum);
 }
 function item(value, index) {
-	const entry = object$5(value);
+	const entry = object$6(value);
 	if (entry === void 0) return void 0;
 	const content = bounded(entry.content ?? entry.text ?? entry.excerpt, MAX_EXCERPT);
 	const explicitTitle = bounded(entry.title ?? entry.label ?? entry.name ?? entry.memoryBodyName, MAX_TITLE);
@@ -12135,7 +12240,7 @@ function item(value, index) {
 	};
 }
 function resultItems(value) {
-	const root = object$5(value);
+	const root = object$6(value);
 	if (root === void 0) return [];
 	const candidates = [
 		root.results,
@@ -12154,8 +12259,8 @@ function resultItems(value) {
 	return items;
 }
 function writeItem(argsValue, operationId) {
-	const outer = object$5(argsValue) ?? {};
-	const input = object$5(outer.input) ?? outer;
+	const outer = object$6(argsValue) ?? {};
+	const input = object$6(outer.input) ?? outer;
 	const content = bounded(input.content ?? input.description ?? input.reason ?? input.summary ?? input.old_text ?? input.oldText, MAX_EXCERPT);
 	const explicitTitle = bounded(input.title ?? input.name, MAX_TITLE);
 	const identity = bounded(input.id ?? input.memoryBodyId ?? input.targetMemoryBodyId ?? input.sourceId, 300);
@@ -12167,7 +12272,7 @@ function writeItem(argsValue, operationId) {
 	};
 }
 function reference(argsValue, key) {
-	return bounded(object$5(argsValue)?.[key], 600);
+	return bounded(object$6(argsValue)?.[key], 600);
 }
 function memoryReadPresentation(sourceTypeId, operationId, referenceKey) {
 	return (args, value) => ({
@@ -12186,7 +12291,7 @@ function memoryWritePresentation(sourceTypeId, operationId, referenceKey) {
 		operationId,
 		...sourceTypeId === void 0 ? {} : { sourceTypeId },
 		...referenceKey === void 0 || reference(args, referenceKey) === void 0 ? {} : { reference: reference(args, referenceKey) },
-		committed: mutationResultCommitted(value) || operationId === "mutate" && object$5(value)?.success === true,
+		committed: mutationResultCommitted(value) || operationId === "mutate" && object$6(value)?.success === true,
 		item: writeItem(args, operationId)
 	});
 }
@@ -12196,7 +12301,7 @@ function namedToolPresentation(name) {
 	return tool.kind === "write" ? memoryWritePresentation(tool.sourceTypeId, tool.operation) : memoryReadPresentation(tool.sourceTypeId, tool.operation);
 }
 function validItem(value) {
-	const entry = object$5(value);
+	const entry = object$6(value);
 	return entry !== void 0 && bounded(entry.id, 300) === entry.id && bounded(entry.title, MAX_TITLE) === entry.title && (entry.excerpt === void 0 || bounded(entry.excerpt, MAX_EXCERPT) === entry.excerpt);
 }
 function cleanItem(value) {
@@ -12209,7 +12314,7 @@ function cleanItem(value) {
 }
 /** Fail closed on arbitrary third-party/session metadata. */
 function parseMnemonActivityMeta(value, callId, toolName) {
-	const meta = object$5(value);
+	const meta = object$6(value);
 	if (meta?.schema !== "dsh-mnemon.activity/v1" || meta.kind !== "read" && meta.kind !== "write") return {};
 	const operationId = bounded(meta.operationId, 300);
 	const sourceTypeId = bounded(meta.sourceTypeId, 128);
@@ -12778,6 +12883,7 @@ var MnemonAgentLifecycle = class {
 	reviewController;
 	reviewRunning = false;
 	reviewAccessBlocked = false;
+	reviewAdmission;
 	lastReviewAt;
 	lastReviewAction;
 	lastReviewScore;
@@ -12815,6 +12921,10 @@ var MnemonAgentLifecycle = class {
 			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))),
 			this.agent.ctx.on("agent/pre-step", ((payload, next) => this.preStep(payload, next)), { prepend: true }),
+			this.agent.ctx.on("agent/request", (async (payload, next) => {
+				await this.prepareReviewAccess(payload);
+				return next();
+			}), { prepend: true }),
 			this.agent.ctx.on("agent/turn-stopping", ((payload) => this.finishTurn(payload)))
 		];
 		return () => {
@@ -12959,18 +13069,28 @@ var MnemonAgentLifecycle = class {
 		activity.toolCallCount = tools.count;
 		activity.toolNames = tools.names;
 		if (!this.reviewActivity().eligible || !this.reviewAdmitted(payload.turn)) return;
+		const admission = this.reviewAdmission;
+		if (admission?.turn === payload.turn && admission.policy === this.reviewPolicy() && admission.available) this.scheduleIdleReview(payload.turn);
+	}
+	async prepareReviewAccess(payload) {
+		this.recordComposedTurn(payload.turn);
+		if (payload.signal.aborted || !this.restoreWatermark() || !this.idleReviewAllowed() || this.turnActivity.get(payload.turn)?.noMaintenance) return;
+		const policy = this.reviewPolicy();
+		if (this.reviewAdmission?.turn === payload.turn && this.reviewAdmission.policy === policy) 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;
+			this.reviewAdmission = {
+				turn: payload.turn,
+				policy,
+				available
+			};
 		} catch (error) {
 			if (!signal.aborted) this.fail(error);
 		} finally {
@@ -12979,7 +13099,6 @@ var MnemonAgentLifecycle = class {
 				this.reviewController = void 0;
 			}
 		}
-		if (admitted) this.scheduleIdleReview(payload.turn);
 	}
 	sessionEvent(session, event) {
 		if (session !== this.agent.session) return;
@@ -13072,6 +13191,7 @@ var MnemonAgentLifecycle = class {
 		if (policy !== this.observedReviewPolicy) {
 			this.cancelIdleReview(true);
 			this.reviewAccessBlocked = false;
+			this.reviewAdmission = void 0;
 		}
 		this.observedReviewPolicy = policy;
 		this.restoreWatermark();
@@ -13871,6 +13991,16 @@ var MnemonLifecycle = class {
 			...typeof effort === "string" && effort !== "" ? { reasoningEffort: effort } : {}
 		};
 	}
+	/** Freeze the effective task route for a paired skill evaluation. */
+	skillTaskRoute(workspaceRoot) {
+		const options = this.taskAgentModelOptions("", workspaceRoot);
+		if (!options?.provider || !options.model) return void 0;
+		return {
+			provider: options.provider,
+			model: options.model,
+			...options.reasoningEffort === void 0 ? {} : { reasoningEffort: options.reasoningEffort }
+		};
+	}
 	taskAgentModelOptions(fallbackSessionId, workspaceRoot) {
 		return this.taskAgentModelRoute(fallbackSessionId, workspaceRoot)?.options;
 	}
@@ -13958,12 +14088,11 @@ var MnemonLifecycle = class {
 						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 {
+					if (payload.step === 1 && this.config.lifecycleEnabled && pinned !== void 0) {
+						const wake = memory.modelWake();
+						if (wake !== void 0 && wake.text.trim() !== "") return {
 							kind: "enter",
 							messages: [...decision.messages, createPluginMessage(wake.text, "recall")]
 						};
@@ -13983,6 +14112,228 @@ var MnemonLifecycle = class {
 	}
 };
 //#endregion
+//#region src/host/skill-auto-adoption.ts
+var AutomaticSkillStop = class extends Error {
+	reason;
+	constructor(reason, detail) {
+		super(detail ?? reason);
+		this.reason = reason;
+	}
+};
+function hashSkillCases(cases) {
+	return createHash("sha256").update(SkillsContracts.skillCaseSignature(cases)).digest("hex");
+}
+function hashSkillDraft(draft) {
+	return createHash("sha256").update(draft.content).digest("hex");
+}
+/** Only fresh idle-review suggestions enter this bounded, in-process queue. */
+var SkillAutoAdoption = class {
+	host;
+	jobs = /* @__PURE__ */ new Map();
+	tail = Promise.resolve();
+	disposed = false;
+	constructor(host) {
+		this.host = host;
+	}
+	enqueue(source, workspace, ids, available) {
+		if (this.disposed || !this.host.settings().autoAdopt) return;
+		for (const id of ids) {
+			if (this.jobs.has(id)) continue;
+			if (this.jobs.size >= 16) {
+				this.record({
+					source,
+					id
+				}, {
+					stage: "review",
+					attempt: 0,
+					reason: "queue-full"
+				}).catch((error) => this.host.warn("Could not record automatic adoption queue limit", error));
+				continue;
+			}
+			const job = {
+				source,
+				workspace,
+				id,
+				available,
+				controller: new AbortController()
+			};
+			this.jobs.set(id, job);
+			this.tail = this.tail.then(() => this.run(job)).catch((error) => this.host.warn("Automatic skill adoption failed", error)).finally(() => {
+				this.jobs.delete(id);
+			});
+		}
+	}
+	allowed(job) {
+		const settings = this.host.settings();
+		return !this.disposed && settings.evolution && settings.autoAdopt && settings.autoBacktest && job.available() && (job.action === void 0 || (job.action === "create" ? settings.allowCreate : settings.allowUpdate));
+	}
+	settingsChanged() {
+		for (const job of this.jobs.values()) if (!this.allowed(job)) job.controller.abort(new AutomaticSkillStop("disabled"));
+	}
+	dispose() {
+		this.disposed = true;
+		for (const job of this.jobs.values()) job.controller.abort(new AutomaticSkillStop("interrupted"));
+	}
+	checkpoint(job) {
+		if (!this.allowed(job)) job.controller.abort(new AutomaticSkillStop(this.disposed ? "interrupted" : "disabled"));
+		job.controller.signal.throwIfAborted();
+	}
+	record(job, event) {
+		return job.source.mutate("auto-adoption-record", {
+			id: job.id,
+			...event
+		});
+	}
+	async unchanged(job, draft, casesHash) {
+		this.checkpoint(job);
+		const current = await job.source.read("draft", { id: draft.id }, job.controller.signal);
+		const suggestion = (await job.source.read("suggestions", null, job.controller.signal)).find((entry) => entry.id === job.id);
+		const cases = (await job.source.read("cases", { skill: draft.skillName }, job.controller.signal)).filter((entry) => entry.enabled);
+		if (current.conflict !== void 0 || current.draft.status !== "ready" || suggestion?.status !== "review" || suggestion.draftId !== draft.id || hashSkillDraft(current.draft) !== hashSkillDraft(draft) || hashSkillCases(cases) !== casesHash) throw new AutomaticSkillStop("changed");
+	}
+	async runs(job, ids) {
+		const deadline = AbortSignal.timeout(276e4);
+		const signal = AbortSignal.any([job.controller.signal, deadline]);
+		for (;;) {
+			this.checkpoint(job);
+			signal.throwIfAborted();
+			const runs = await Promise.all(ids.map((id) => job.source.read("run", { id }, signal)));
+			if (runs.some((run) => run.status !== "running" && run.status !== "completed") || runs.every((run) => run.status !== "running")) return runs;
+			await setTimeout$1(250, void 0, { signal });
+		}
+	}
+	async run(job) {
+		const runIds = /* @__PURE__ */ new Set();
+		let attempt = 0;
+		let scores = {};
+		try {
+			this.checkpoint(job);
+			const suggestion = (await job.source.read("suggestions")).find((entry) => entry.id === job.id);
+			if (suggestion?.status !== "pending" || suggestion.draftId !== void 0) throw new AutomaticSkillStop("changed");
+			job.action = suggestion.action;
+			this.checkpoint(job);
+			const settings = this.host.settings();
+			const reserved = await job.source.mutate("auto-adoption-reserve", {
+				id: job.id,
+				limit: settings.autoAdoptDailyLimit,
+				timeZone: settings.autoAdoptTimeZone
+			}, job.controller.signal);
+			if (!reserved.allowed) throw new AutomaticSkillStop(reserved.reason, `${reserved.used}/${reserved.limit} · ${reserved.date} · ${reserved.timeZone}`);
+			await this.record(job, {
+				stage: "queued",
+				attempt,
+				detail: `${reserved.used}/${reserved.limit} · ${reserved.date} · ${reserved.timeZone}`
+			});
+			const cases = (await job.source.read("cases", { skill: suggestion.skillName })).filter((entry) => entry.enabled);
+			if (cases.length === 0) throw new AutomaticSkillStop("no-cases");
+			if (cases.some((entry) => entry.requiresVision === true || entry.checks.length === 0)) throw new AutomaticSkillStop("unmeasured");
+			if (cases.length > this.host.settings().casesPerRun) throw new AutomaticSkillStop("case-limit");
+			const casesHash = hashSkillCases(cases);
+			const preferences = await job.source.read("draft-preferences");
+			const defaultRoute = this.host.route(job.workspace);
+			const runRoute = preferences.skillRunModels[suggestion.skillName] ?? preferences.runModel ?? defaultRoute;
+			const draftRoute = preferences.suggestionModels[job.id] ?? preferences.model ?? defaultRoute;
+			if (runRoute === void 0 || draftRoute === void 0) throw new AutomaticSkillStop("model-unavailable");
+			let previous;
+			let guidance = "";
+			for (attempt = 1; attempt <= 3; attempt++) {
+				this.checkpoint(job);
+				await this.record(job, {
+					stage: "drafting",
+					attempt
+				});
+				const draft = await this.host.draft(job.source, job.workspace, {
+					suggestionId: job.id,
+					action: suggestion.action,
+					...previous === void 0 ? {} : { previous },
+					guidance,
+					route: draftRoute
+				}, job.controller.signal);
+				await this.unchanged(job, draft, casesHash);
+				await this.record(job, {
+					stage: "backtesting",
+					attempt
+				});
+				const baseline = await this.host.backtest(job.source, job.workspace, {
+					skillName: draft.skillName,
+					target: {
+						kind: draft.action === "update" ? "current" : "none",
+						...draft.action === "update" ? { draftId: draft.id } : {}
+					},
+					route: runRoute,
+					expectedCasesHash: casesHash,
+					signal: job.controller.signal
+				});
+				runIds.add(baseline.runId);
+				this.checkpoint(job);
+				const candidate = await this.host.backtest(job.source, job.workspace, {
+					skillName: draft.skillName,
+					target: {
+						kind: "draft",
+						draftId: draft.id
+					},
+					route: runRoute,
+					expectedCasesHash: casesHash,
+					signal: job.controller.signal
+				});
+				runIds.add(candidate.runId);
+				await job.source.mutate("run-link", {
+					draftId: draft.id,
+					runId: baseline.runId
+				}, job.controller.signal);
+				const [before, after] = await this.runs(job, [baseline.runId, candidate.runId]);
+				await this.unchanged(job, draft, casesHash);
+				const comparison = SkillsContracts.compareAutomaticSkillRuns(cases, before, after, casesHash);
+				scores = {
+					...comparison.baselineScore === void 0 ? {} : { baselineScore: comparison.baselineScore },
+					...comparison.draftScore === void 0 ? {} : { draftScore: comparison.draftScore }
+				};
+				if (comparison.outcome === "unmeasured") throw new AutomaticSkillStop("unmeasured");
+				if (comparison.outcome === "not-worse") {
+					this.checkpoint(job);
+					await job.source.mutate("draft-adopt", {
+						id: draft.id,
+						automatic: {
+							reservationId: reserved.reservationId,
+							draftHash: hashSkillDraft(draft),
+							baselineRunId: baseline.runId,
+							draftRunId: candidate.runId,
+							casesHash,
+							attempt
+						}
+					}, job.controller.signal);
+					return;
+				}
+				if (attempt === 3) throw new AutomaticSkillStop("regressed");
+				await this.record(job, {
+					stage: "rewriting",
+					attempt,
+					reason: "regressed",
+					...scores
+				});
+				guidance = `The previous draft regressed in paired backtests. Baseline score: ${comparison.baselineScore}; previous draft score: ${comparison.draftScore}. Improve each regressed case without losing any previously passing check.\n` + JSON.stringify(cases.map((entry) => ({
+					title: entry.title,
+					baseline: before.results.find((result) => result.caseId === entry.id),
+					draft: after.results.find((result) => result.caseId === entry.id)
+				}))).slice(0, 8e3);
+				previous = draft;
+			}
+		} catch (error) {
+			const failure = job.controller.signal.aborted ? job.controller.signal.reason : error;
+			const reason = failure instanceof AutomaticSkillStop ? failure.reason : "failed";
+			await this.record(job, {
+				stage: reason === "disabled" || reason === "interrupted" ? "paused" : "review",
+				attempt: Math.min(attempt, 3),
+				reason,
+				...scores,
+				...failure instanceof AutomaticSkillStop && failure.message === failure.reason ? {} : { detail: failure instanceof Error ? failure.message : String(failure) }
+			}).catch((recordError) => this.host.warn("Could not record automatic adoption outcome", recordError));
+		} finally {
+			for (const id of runIds) await job.source.mutate("run-cancel", { id }).catch((error) => this.host.warn("Could not stop automatic skill backtest", error));
+		}
+	}
+};
+//#endregion
 //#region src/host/skill-review.ts
 const SIGNALS = [
 	"correction",
@@ -14815,7 +15166,7 @@ function retryingSource(source, attempts = 4) {
 			for (let attempt = 1;; attempt++) try {
 				return await source.mutate(operation, input, signal);
 			} catch (error) {
-				if (attempt >= attempts || !/revision conflict|changed since it was read; reload/u.test(error instanceof Error ? error.message : String(error))) throw error;
+				if (attempt >= attempts || !/revision conflict|Skills Source changed since it was read; reload/u.test(error instanceof Error ? error.message : String(error))) throw error;
 			}
 		}
 	};
@@ -14823,6 +15174,27 @@ function retryingSource(source, attempts = 4) {
 function message(error) {
 	return redact(error instanceof Error ? error.message : String(error));
 }
+/**
+* A draft task that stops reporting is abandoned here. The subagent behind it
+* can die without settling, and the suggestion would otherwise stay `drafting`
+* - blocking dismiss, delete and a retry - until the Host restarts.
+*/
+const DRAFT_DEADLINE_MS = 9e5;
+/** Distinguishes a deadline abort from the plain abort a Host shutdown sends. */
+var DraftDeadlineError = class extends Error {};
+/** The deadline error a task ran into, so the Source records why the draft ended. */
+function deadlineReason(signal) {
+	return signal.reason instanceof DraftDeadlineError ? signal.reason : void 0;
+}
+/** Cancellation settles the owner even when an underlying task ignores its signal. */
+function abortable(signal, work) {
+	signal.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		Promise.resolve().then(work).then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+	});
+}
 /** Resolve only roots supplied by this Source's scoped catalog, never the task's cwd. */
 function newSkillRoot(settings, source, catalog, explicit) {
 	let root = explicit;
@@ -14830,7 +15202,9 @@ function newSkillRoot(settings, source, catalog, explicit) {
 		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;
+	const destination = catalog.roots.find((candidate) => candidate.kind === root);
+	if (destination?.readOnly) throw new Error(`Cannot create a skill in ${root}: linked skill roots are read-only.`);
+	const directory = destination?.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");
@@ -14863,8 +15237,22 @@ var SkillEvolution = class {
 	sessions = /* @__PURE__ */ new Map();
 	jobs = /* @__PURE__ */ new Set();
 	disposed = false;
+	activeBacktests = 0;
+	backtestJobs = 0;
+	backtestWaiters = /* @__PURE__ */ new Set();
+	automatic;
 	constructor(host) {
 		this.host = host;
+		this.automatic = new SkillAutoAdoption({
+			settings: () => host.settings(),
+			route: (workspace) => host.taskRoute?.(workspace),
+			draft: (source, workspace, input, signal) => this.automaticDraft(source, workspace, input, signal),
+			backtest: (source, workspace, input) => this.backtest(source, workspace, input),
+			warn: (text, error) => this.warn(text, error)
+		});
+	}
+	settingsChanged() {
+		this.automatic.settingsChanged();
 	}
 	source(agent) {
 		const source = this.host.source(agent);
@@ -15098,6 +15486,7 @@ var SkillEvolution = class {
 			});
 			state.failures = 0;
 			state.lastReviewAt = this.now().getTime();
+			if (trigger === "automatic" && result.createdSuggestionIds !== void 0) this.automatic.enqueue(source, workspace, result.createdSuggestionIds, () => this.host.source(agent) !== void 0);
 			return result;
 		} catch (error) {
 			state.failures += 1;
@@ -15128,10 +15517,17 @@ var SkillEvolution = class {
 			delete state.reviewing;
 		}
 	}
-	background(name, work) {
+	background(name, work, deadlineMs) {
 		const controller = new AbortController();
 		this.jobs.add(controller);
-		work(controller.signal).catch((error) => this.warn(`${name} failed`, error)).finally(() => this.jobs.delete(controller));
+		const timer = deadlineMs === void 0 ? void 0 : setTimeout(() => {
+			controller.abort(new DraftDeadlineError(`${name} did not finish within ${Math.round(deadlineMs / 6e4)} minutes`));
+		}, deadlineMs);
+		timer?.unref?.();
+		return work(controller.signal).catch((error) => this.warn(`${name} failed`, deadlineReason(controller.signal) ?? error)).finally(() => {
+			if (timer !== void 0) clearTimeout(timer);
+			this.jobs.delete(controller);
+		});
 	}
 	/**
 	* Write a draft for a suggestion (or for a skill directly) in the
@@ -15144,6 +15540,7 @@ var SkillEvolution = class {
 			...input.draftId === void 0 ? {} : { draftId: input.draftId },
 			...input.skill === void 0 ? {} : { skill: input.skill }
 		});
+		if (pack.skill?.readOnly) throw new Error("Linked skills are read-only; use a local copy before generating an improvement draft.");
 		const previousId = input.draftId ?? pack.suggestion?.draftId;
 		const previous = previousId === void 0 ? (await source.read("drafts", {
 			skill: pack.skillName,
@@ -15157,26 +15554,84 @@ var SkillEvolution = class {
 			status: "drafting"
 		});
 		this.background("skill draft", async (signal) => {
+			let recorded = false;
 			try {
-				await this.writeDraft(source, workspace, input, {
+				await abortable(signal, () => this.writeDraft(source, workspace, input, {
 					pack,
 					targetRoot,
-					guidance
-				}, signal);
+					guidance,
+					onRecorded: () => {
+						recorded = true;
+					}
+				}, signal));
 			} catch (error) {
-				if (input.suggestionId !== void 0) await source.mutate("suggestion-status", {
-					id: input.suggestionId,
-					status: "pending",
-					error: message(error)
-				}).catch(() => void 0);
+				if (!recorded && input.suggestionId !== void 0) {
+					if ((await source.read("suggestions")).find((item) => item.id === input.suggestionId)?.status === "drafting") await source.mutate("suggestion-status", {
+						id: input.suggestionId,
+						status: "pending",
+						error: message(deadlineReason(signal) ?? error)
+					}).catch(() => void 0);
+				}
 				throw error;
 			}
-		});
+		}, DRAFT_DEADLINE_MS);
 		return {
 			started: true,
 			...input.suggestionId === void 0 ? {} : { suggestionId: input.suggestionId }
 		};
 	}
+	async automaticDraft(source, workspace, input, parentSignal) {
+		const controller = new AbortController();
+		const signal = AbortSignal.any([parentSignal, controller.signal]);
+		const timer = setTimeout(() => controller.abort(new DraftDeadlineError("Automatic skill draft did not finish within 15 minutes")), DRAFT_DEADLINE_MS);
+		timer.unref?.();
+		const expectedDraft = input.previous === void 0 ? null : {
+			id: input.previous.id,
+			hash: hashSkillDraft(input.previous)
+		};
+		let recorded = false;
+		let claimed = false;
+		try {
+			return await abortable(signal, async () => {
+				const pack = await source.read("evidence-pack", { suggestionId: input.suggestionId }, signal);
+				signal.throwIfAborted();
+				if (pack.skill?.readOnly) throw new AutomaticSkillStop("changed");
+				if (pack.action !== input.action || pack.action === "update" && pack.suggestion?.skillFileHash !== pack.skill?.hash) throw new AutomaticSkillStop("changed");
+				const targetRoot = pack.action === "update" ? pack.skill.root : newSkillRoot(this.host.settings(), source, await source.read("catalog", null, signal), input.previous?.targetRoot ?? pack.suggestion?.targetRoot);
+				const guidance = [...input.previous?.guidance ?? [], ...input.guidance === "" ? [] : [input.guidance]].slice(-8);
+				await source.mutate("suggestion-status", {
+					id: input.suggestionId,
+					status: "drafting",
+					expectedDraft
+				}, signal);
+				claimed = true;
+				return this.writeDraft(source, workspace, {
+					suggestionId: input.suggestionId,
+					...input.previous === void 0 ? {} : { draftId: input.previous.id },
+					route: input.route
+				}, {
+					pack,
+					targetRoot,
+					guidance,
+					expectedDraft,
+					deferBacktests: true,
+					onRecorded: () => {
+						recorded = true;
+					}
+				}, signal);
+			});
+		} catch (error) {
+			if (claimed && !recorded) await source.mutate("suggestion-status", {
+				id: input.suggestionId,
+				status: "pending",
+				expectedDraft,
+				...parentSignal.aborted ? {} : { error: message(signal.aborted ? signal.reason : error) }
+			}).catch(() => void 0);
+			throw signal.aborted ? signal.reason : error;
+		} finally {
+			clearTimeout(timer);
+		}
+	}
 	async writeDraft(source, workspace, input, prepared, signal) {
 		const settings = this.host.settings();
 		const { pack, targetRoot, guidance } = prepared;
@@ -15213,15 +15668,19 @@ var SkillEvolution = class {
 					notes: parsed.notes,
 					changes: parsed.changes,
 					guidance,
+					expectedBaseHash: pack.skill?.hash ?? null,
+					...prepared.expectedDraft === void 0 ? {} : { expectedDraft: prepared.expectedDraft },
 					...pack.action === "create" ? { targetRoot } : {}
 				}, signal);
+				prepared.onRecorded?.();
 			} catch (error) {
 				signal.throwIfAborted();
-				if (attempt > 0) throw error;
+				if (attempt > 0 || /changed while this draft/.test(message(error))) throw error;
 				prompt += `\n\nYour previous SKILL.md was rejected: ${message(error)}. Return a corrected complete file.`;
 			}
 		}
-		if (settings.autoBacktest && pack.cases.length > 0) {
+		signal.throwIfAborted();
+		if (!prepared.deferBacktests && (settings.autoBacktest || input.backtest) && pack.cases.length > 0) {
 			await this.backtest(source, workspace, {
 				skillName: pack.skillName,
 				target: {
@@ -15252,67 +15711,138 @@ var SkillEvolution = class {
 		return draft;
 	}
 	/** Start a backtest of one version of a skill against its enabled cases; it runs in the background. */
+	backtestSlot(signal) {
+		signal.throwIfAborted();
+		return new Promise((resolve, reject) => {
+			const abort = () => {
+				this.backtestWaiters.delete(acquire);
+				reject(signal.reason);
+			};
+			const acquire = () => {
+				if (signal.aborted) {
+					abort();
+					return;
+				}
+				if (this.activeBacktests >= 2) return;
+				this.backtestWaiters.delete(acquire);
+				signal.removeEventListener("abort", abort);
+				this.activeBacktests++;
+				resolve(() => {
+					this.activeBacktests--;
+					for (const waiter of [...this.backtestWaiters]) waiter();
+				});
+			};
+			this.backtestWaiters.add(acquire);
+			signal.addEventListener("abort", abort, { once: true });
+			acquire();
+		});
+	}
 	async backtest(port, workspace, input) {
+		if (this.disposed) throw new Error("Skill evolution has stopped");
+		input.signal?.throwIfAborted();
+		if (this.backtestJobs >= 16) throw new Error("The skill backtest queue is full. Cancel a run or retry after it finishes.");
+		this.backtestJobs++;
 		const source = retryingSource(port);
-		const settings = this.host.settings();
-		const cases = (await source.read("cases", { skill: input.skillName })).filter((entry) => entry.enabled && (input.caseIds === void 0 || input.caseIds.includes(entry.id))).slice(0, settings.casesPerRun);
-		if (cases.length === 0) throw new Error(`${input.skillName} has no enabled eval case to run`);
-		if (cases.some((entry) => entry.requiresVision !== void 0 && typeof entry.requiresVision !== "boolean")) throw new Error("requiresVision must be a boolean");
-		const resolved = await source.read("target-content", {
-			skillName: input.skillName,
-			target: input.target
-		});
-		const run = await source.mutate("run-start", {
-			skillName: input.skillName,
-			target: resolved.target,
-			caseIds: cases.map((entry) => entry.id)
-		});
-		this.background("skill backtest", async (signal) => {
-			try {
-				for (const entry of cases.filter((entry) => entry.requiresVision === true)) {
-					signal.throwIfAborted();
-					await source.mutate("run-progress", {
-						id: run.id,
-						result: {
-							caseId: entry.id,
-							title: entry.title,
-							verdict: "error",
-							score: 0,
-							unmeasuredReason: "requires-vision",
-							checks: [],
-							steps: [],
-							answer: "",
-							error: "Not measured: this case requires image input, which text-only backtests cannot receive."
-						}
+		try {
+			const settings = this.host.settings();
+			const cases = (await source.read("cases", { skill: input.skillName }, input.signal)).filter((entry) => entry.enabled && (input.caseIds === void 0 || input.caseIds.includes(entry.id))).slice(0, settings.casesPerRun);
+			if (cases.length === 0) throw new Error(`${input.skillName} has no enabled eval case to run`);
+			if (input.expectedCasesHash !== void 0 && hashSkillCases(cases) !== input.expectedCasesHash) throw new Error("Eval cases changed before this backtest started");
+			if (cases.some((entry) => entry.requiresVision !== void 0 && typeof entry.requiresVision !== "boolean")) throw new Error("requiresVision must be a boolean");
+			const resolved = await source.read("target-content", {
+				skillName: input.skillName,
+				target: input.target
+			}, input.signal);
+			const run = await source.mutate("run-start", {
+				skillName: input.skillName,
+				target: resolved.target,
+				caseIds: cases.map((entry) => entry.id),
+				...input.expectedCasesHash === void 0 ? {} : { expectedCasesHash: input.expectedCasesHash },
+				...input.route === void 0 ? {} : { model: input.route }
+			}, input.signal);
+			this.background("skill backtest", async (deadline) => {
+				const controller = new AbortController();
+				const abort = () => controller.abort(deadline.aborted ? deadline.reason : input.signal?.reason);
+				deadline.addEventListener("abort", abort, { once: true });
+				input.signal?.addEventListener("abort", abort, { once: true });
+				if (deadline.aborted || input.signal?.aborted) abort();
+				const signal = controller.signal;
+				let checking = false;
+				const watcher = setInterval(() => {
+					if (checking || signal.aborted) return;
+					checking = true;
+					source.read("run", { id: run.id }).then((current) => {
+						if (current.status !== "running") controller.abort(new Error(current.error ?? "Backtest interrupted"));
+					}).catch((error) => controller.abort(error)).finally(() => {
+						checking = false;
 					});
-				}
-				const queue = cases.filter((entry) => entry.requiresVision !== true);
-				if (queue.length > 0) await this.host.runTask(workspace, signal, async (task) => {
-					const worker = async () => {
-						for (let entry = queue.shift(); entry !== void 0; entry = queue.shift()) {
+				}, 1e3);
+				watcher.unref?.();
+				try {
+					await abortable(signal, async () => {
+						const release = await this.backtestSlot(signal);
+						try {
+							for (const entry of cases.filter((entry) => entry.requiresVision === true)) {
+								signal.throwIfAborted();
+								await source.mutate("run-progress", {
+									id: run.id,
+									result: {
+										caseId: entry.id,
+										title: entry.title,
+										verdict: "error",
+										score: 0,
+										unmeasuredReason: "requires-vision",
+										checks: [],
+										steps: [],
+										answer: "",
+										error: "Not measured: this case requires image input, which text-only backtests cannot receive."
+									}
+								}, signal);
+							}
+							const queue = cases.filter((entry) => entry.requiresVision !== true);
+							if (queue.length > 0) await abortable(signal, () => this.host.runTask(workspace, signal, async (task) => {
+								const worker = async () => {
+									for (let entry = queue.shift(); entry !== void 0; entry = queue.shift()) {
+										signal.throwIfAborted();
+										const result = await this.runCase(task, entry, input.skillName, resolved.content, signal);
+										signal.throwIfAborted();
+										await source.mutate("run-progress", {
+											id: run.id,
+											result
+										}, signal);
+									}
+								};
+								await Promise.all(Array.from({ length: Math.min(BACKTEST_CONCURRENCY, queue.length) }, worker));
+							}, input.route));
 							signal.throwIfAborted();
-							await source.mutate("run-progress", {
+							await source.mutate("run-finish", {
 								id: run.id,
-								result: await this.runCase(task, entry, input.skillName, resolved.content, signal)
-							});
+								status: "completed"
+							}, signal);
+						} finally {
+							release();
 						}
-					};
-					await Promise.all(Array.from({ length: Math.min(BACKTEST_CONCURRENCY, queue.length) }, worker));
-				}, input.route);
-				await source.mutate("run-finish", {
-					id: run.id,
-					status: "completed"
-				});
-			} catch (error) {
-				await source.mutate("run-finish", {
-					id: run.id,
-					status: "failed",
-					error: message(error)
-				}).catch(() => void 0);
-				throw error;
-			}
-		});
-		return { runId: run.id };
+					});
+				} catch (error) {
+					await source.mutate("run-finish", {
+						id: run.id,
+						status: signal.aborted ? "interrupted" : "failed",
+						error: message(signal.aborted ? signal.reason : error)
+					}).catch(() => void 0);
+					throw error;
+				} finally {
+					clearInterval(watcher);
+					deadline.removeEventListener("abort", abort);
+					input.signal?.removeEventListener("abort", abort);
+				}
+			}, 27e5).finally(() => {
+				this.backtestJobs--;
+			});
+			return { runId: run.id };
+		} catch (error) {
+			this.backtestJobs--;
+			throw error;
+		}
 	}
 	/**
 	* Execute and grade one case. A run that fails (an output limit, a missing
@@ -15326,9 +15856,15 @@ var SkillEvolution = class {
 				name: skillName,
 				...content === void 0 ? {} : { content }
 			}), SKILL_EXECUTOR_SCHEMA, SKILL_EXECUTOR_PERSONA, signal)).structured);
-			const grade = gradeCase(entry, (await this.host.skillTask(task, `Mnemon skill judge: ${entry.title}`.slice(0, 120), skillJudgePrompt(entry, executed.steps, executed.answer), SKILL_JUDGE_SCHEMA, SKILL_JUDGE_PERSONA, signal)).structured);
+			signal.throwIfAborted();
+			const judged = await this.host.skillTask(task, `Mnemon skill judge: ${entry.title}`.slice(0, 120), skillJudgePrompt(entry, executed.steps, executed.answer), SKILL_JUDGE_SCHEMA, SKILL_JUDGE_PERSONA, signal);
+			const grade = gradeCase(entry, judged.structured);
+			const raw = judged.structured;
+			const checks = Array.isArray(raw?.checks) ? raw.checks : [];
+			const fullyGraded = checks.length === entry.checks.length && entry.checks.every((_check, index) => checks.filter((check) => check?.index === index + 1 && typeof check.pass === "boolean").length === 1);
 			return {
 				caseId: entry.id,
+				fullyGraded,
 				title: entry.title,
 				verdict: grade.verdict,
 				score: grade.score,
@@ -15438,6 +15974,7 @@ var SkillEvolution = class {
 		};
 	}
 	dispose() {
+		this.automatic.dispose();
 		this.disposed = true;
 		for (const state of this.sessions.values()) if (state.timer !== void 0) clearTimeout(state.timer);
 		this.sessions.clear();
@@ -15472,7 +16009,7 @@ function skillsSourceFor(runtime, agent) {
 }
 //#endregion
 //#region src/host/rpc.ts
-function object$4(value) {
+function object$5(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("payload must be an object");
 	return value;
 }
@@ -15668,7 +16205,7 @@ async function assisted(runtime, lifecycle, typeId, operation, input, signal, ta
 				...signal === void 0 ? {} : { signal }
 			});
 			return {
-				...object$4(result.value),
+				...object$5(result.value),
 				revision: result.revision
 			};
 		} finally {
@@ -15783,6 +16320,7 @@ async function skillAssistance(runtime, lifecycle, operation, input, signal) {
 			if (guidance !== void 0 && guidance.length > 4e3) throw new Error("guidance is too long (max 4000 characters)");
 			const draftRoute = modelRoute(input);
 			return skills.draft(source, workspaceRoot, {
+				...input.backtest === true ? { backtest: true } : {},
 				...suggestionId === void 0 ? {} : { suggestionId },
 				...skill === void 0 ? {} : { skill },
 				...draftId === void 0 ? {} : { draftId },
@@ -15794,7 +16332,7 @@ async function skillAssistance(runtime, lifecycle, operation, input, signal) {
 		case "skill-backtest": {
 			const skillName = optionalString(input.skillName, "skillName");
 			if (skillName === void 0) throw new Error("skillName is required");
-			const target = object$4(input.target);
+			const target = object$5(input.target);
 			if (![
 				"current",
 				"draft",
@@ -15834,7 +16372,7 @@ async function skillAssistance(runtime, lifecycle, operation, input, signal) {
 function createReadHandler(input, lifecycle, versions) {
 	return async (endpoint, rawPayload, signal) => {
 		try {
-			const payload = object$4(rawPayload);
+			const payload = object$5(rawPayload);
 			if (endpoint === "versions") {
 				if (versions === void 0) throw new Error("version checks are unavailable");
 				return success$1(await versions.check());
@@ -15855,7 +16393,7 @@ function createReadHandler(input, lifecycle, versions) {
 					if (lifecycle === void 0 || payload.operation !== "agent-search") throw new Error("Read-only Host assistance is unavailable");
 					const source = (await catalog(runtime, lifecycle)).sources.find((item) => item.sourceInstanceKey === payload.sourceInstanceKey);
 					if (source === void 0 || !source.assistance.includes("agent-search")) throw new Error("Host assistance is not available for this Source instance");
-					const value = await assisted(runtime, lifecycle, source.sourceTypeId, "agent-search", object$4(payload.input), signal);
+					const value = await assisted(runtime, lifecycle, source.sourceTypeId, "agent-search", object$5(payload.input), signal);
 					return success$1({
 						revision: (await catalog(runtime)).sources.find((item) => item.sourceInstanceKey === source.sourceInstanceKey)?.revision ?? source.revision,
 						value
@@ -15967,9 +16505,9 @@ function createActivationHandler(input) {
 	return async (endpoint, rawPayload, signal) => {
 		try {
 			if (endpoint === "source-assistance") {
-				const payload = object$4(rawPayload);
+				const payload = object$5(rawPayload);
 				if (payload.operation !== "activation" || payload.confirmed !== true) throw new Error("Unsupported activation operation");
-				const fields = object$4(payload.input);
+				const fields = object$5(payload.input);
 				if (Object.keys(fields).some((key) => key !== "memoryBodyId" && key !== "active") || typeof fields.active !== "boolean" || typeof fields.memoryBodyId !== "string") throw new Error("Activation accepts only a Memory Space id and boolean state");
 				const runtime = scoped(input, payload);
 				requireWritable(runtime);
@@ -15993,7 +16531,7 @@ function createActivationHandler(input) {
 				}
 			}
 			if (endpoint !== "body") return badRequest$1("unknown activation endpoint: " + endpoint);
-			const payload = object$4(rawPayload);
+			const payload = object$5(rawPayload);
 			const unexpected = Object.keys(payload).filter((field) => !ACTIVATION_FIELDS.has(field));
 			if (unexpected.length > 0) return badRequest$1("unsupported activation fields: " + unexpected.join(", "));
 			if (typeof payload.memoryBodyId !== "string" || payload.memoryBodyId.trim() === "") return badRequest$1("memoryBodyId must be a non-empty string");
@@ -16012,7 +16550,7 @@ function createActivationHandler(input) {
 function createWriteHandler(input, lifecycle, versions) {
 	return async (endpoint, rawPayload, signal) => {
 		try {
-			const payload = object$4(rawPayload);
+			const payload = object$5(rawPayload);
 			if (endpoint === "version-update") {
 				if (versions === void 0) throw new Error("version updates are unavailable");
 				if (!input.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
@@ -16048,12 +16586,12 @@ function createWriteHandler(input, lifecycle, versions) {
 				if (source === void 0 || !source.assistance.includes(operation)) throw new Error("Host assistance is not available for this Source instance");
 				requireLayerOn(runtime, source.sourceTypeId);
 				if (operation !== "agent-search" && (payload.confirmed !== true || payload.expectedRevision !== source.revision)) throw new Error("Host assistance requires confirmation of the current Source revision");
-				const value = await assisted(runtime, lifecycle, source.sourceTypeId, operation, object$4(payload.input), signal, {
+				const value = await assisted(runtime, lifecycle, source.sourceTypeId, operation, object$5(payload.input), signal, {
 					sourceInstanceKey: source.sourceInstanceKey,
 					expectedRevision: source.revision
 				});
 				if (source.sourceTypeId === "runtime") return success$1({
-					revision: object$4(value).revision,
+					revision: object$5(value).revision,
 					value
 				});
 				return success$1({
@@ -16097,7 +16635,7 @@ function createWriteHandler(input, lifecycle, versions) {
 function createPackHandler(input, nativeDirectoryPicker = () => false) {
 	return async (endpoint, rawPayload) => {
 		try {
-			const payload = object$4(rawPayload);
+			const payload = object$5(rawPayload);
 			const runtime = scoped(input, payload);
 			const manager = runtime.graph.packs;
 			if (endpoint === "target") return success$1({
@@ -16134,7 +16672,7 @@ function githubAuth(input) {
 function createSyncHandler(input, onConfigured) {
 	return async (endpoint, rawPayload, signal) => {
 		try {
-			const payload = object$4(rawPayload);
+			const payload = object$5(rawPayload);
 			const runtime = scoped(input, payload);
 			const sync = runtime.graph.sync;
 			if (endpoint === "status") return success$1(await sync.status(signal));
@@ -16207,7 +16745,7 @@ function createSyncHandler(input, onConfigured) {
 function createReviewHandler(input, lifecycle) {
 	return async (endpoint, rawPayload, signal) => {
 		try {
-			const payload = object$4(rawPayload);
+			const payload = object$5(rawPayload);
 			const ledger = input.reviews;
 			if (endpoint === "view") return success$1(ledger.view());
 			if (endpoint === "opinion") {
@@ -16294,6 +16832,106 @@ function hasNativeDirectoryPicker(ctx) {
 	}
 }
 //#endregion
+//#region src/host/embedding-settings.ts
+const object$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+/** Preserve other Host redaction while never returning a legacy inline key. */
+function publicEmbeddingSettings(value, original, metadata = false) {
+	const config = object$4(value);
+	if (!metadata && config.embedding === void 0) return value;
+	const embedding = object$4(config.embedding);
+	const raw = object$4(object$4(original).embedding);
+	const apiKeyStorage = raw.apiKeyEnv ? "environment" : raw.apiKeyRef ? "credentials" : raw.apiKey ? "legacy" : "none";
+	return {
+		...config,
+		embedding: {
+			...embedding,
+			..."apiKey" in embedding ? { apiKey: "" } : {},
+			...metadata ? {
+				apiKeyStorage,
+				apiKeyConfigured: apiKeyStorage !== "none"
+			} : {}
+		}
+	};
+}
+/** Write/verify a new record before referencing it; failures keep the old configuration and key intact. */
+async function prepareEmbeddingSettings(settings, namespace, operations, revision, store) {
+	const last = operations.findLastIndex((operation) => operation.path.length === 1 && operation.path[0] === "embedding");
+	if (namespace !== "mnemon" || last === -1) return {
+		operations,
+		revision
+	};
+	const operation = operations[last];
+	const edits = operations.filter((entry, index) => index === last || entry.path[0] !== "embedding");
+	if (operation.op === "unset") return {
+		operations: edits,
+		revision
+	};
+	const view = settings.describe({ redactSecrets: false }).find((candidate) => candidate.ns === namespace);
+	if (view === void 0) throw new Error("Mnemon settings are unavailable");
+	if (revision !== void 0 && revision !== view.revision) throw new Error("Settings changed; reload before saving the embedding connection");
+	const previous = resolveEmbedding(object$4(object$4(view.value).embedding));
+	const input = object$4(operation.value);
+	if (typeof operation.value !== "object" || operation.value === null || Array.isArray(operation.value)) throw new Error("Embedding settings must be an object");
+	if (input.apiKey !== void 0 && typeof input.apiKey !== "string") throw new Error("Embedding API key must be text");
+	if (input.clearApiKey !== void 0 && typeof input.clearApiKey !== "boolean") throw new Error("clearApiKey must be boolean");
+	const { apiKeyStorage: _storage, apiKeyConfigured: _configured, clearApiKey: _clear, ...next } = input;
+	let resolved = resolveEmbedding(next);
+	let rollback;
+	if (input.clearApiKey === true) {
+		next.apiKey = "";
+		next.apiKeyRef = "";
+		next.apiKeyEnv = "";
+	} else if (resolved.apiKeyEnv) {
+		if (resolved.apiKey) throw new Error("Choose an embedding API key or an environment variable, not both");
+		next.apiKey = "";
+		next.apiKeyRef = "";
+	} else {
+		if (resolved.apiKeyRef && resolved.apiKeyRef !== previous.apiKeyRef) throw new Error("Save a key to create an embedding credential reference");
+		const sameEndpoint = resolved.endpoint === previous.endpoint;
+		if (!resolved.apiKey && !sameEndpoint && (previous.apiKeyRef || previous.apiKey)) throw new Error("Changing the embedding endpoint requires a new key, an environment variable, or explicitly removing the saved key");
+		const key = resolved.apiKey || (sameEndpoint ? previous.apiKey : "");
+		if (key) {
+			const credentials = store?.();
+			if (credentials === void 0) throw new Error("DSH credentials storage is unavailable; configure apiKeyEnv instead. The existing connection was not changed");
+			const reference = EMBEDDING_CREDENTIAL_PREFIX + randomUUID();
+			const payload = {
+				version: 1,
+				endpoint: resolved.endpoint,
+				apiKey: key
+			};
+			rollback = async () => {
+				await credentials.deleteRecord(reference);
+			};
+			try {
+				await credentials.modifyRecord(reference, async () => ({
+					kind: "grant",
+					payload
+				}));
+				const record = await credentials.readRecord(reference);
+				if (record?.kind !== "grant" || record.payload?.version !== 1 || record.payload.endpoint !== payload.endpoint || record.payload.apiKey !== key) throw new Error("Credential readback failed");
+			} catch {
+				await rollback().catch(() => {});
+				throw new Error("Could not save and verify the embedding credential; the existing connection was not changed");
+			}
+			next.apiKey = "";
+			next.apiKeyRef = reference;
+		} else if (sameEndpoint && previous.apiKeyRef) {
+			next.apiKey = "";
+			next.apiKeyRef = previous.apiKeyRef;
+		}
+	}
+	resolved = resolveEmbedding(next);
+	if (resolved.apiKey) throw new Error("Embedding settings must not persist a plaintext key");
+	return {
+		operations: edits.map((entry) => entry === operation ? {
+			...entry,
+			value: next
+		} : entry),
+		revision: revision ?? view.revision,
+		...rollback === void 0 ? {} : { rollback }
+	};
+}
+//#endregion
 //#region src/host/settings.ts
 function success(value) {
 	return {
@@ -16324,14 +16962,16 @@ function badRequest(message) {
 function descriptor(settings, namespace) {
 	const view = settings.describe({ redactSecrets: true }).find((candidate) => candidate.ns === namespace);
 	if (view === void 0) throw new Error(`${namespace} settings namespace is unavailable`);
+	const raw = namespace === "mnemon" ? settings.describe({ redactSecrets: false }).find((candidate) => candidate.ns === namespace) : void 0;
+	const visible = namespace === "mnemon" ? publicEmbeddingSettings(view.value, raw?.value, true) : view.value;
 	return {
 		status: "ready",
 		value: namespace === "mnemon" && displayModeOf(view.value) === "buildin" ? {
-			...object$3(view.value),
+			...object$3(visible),
 			displayMode: "builtin"
-		} : view.value,
-		base: view.base,
-		user: view.user,
+		} : visible,
+		base: namespace === "mnemon" ? publicEmbeddingSettings(view.base, raw?.base) : view.base,
+		user: namespace === "mnemon" ? publicEmbeddingSettings(view.user, raw?.user) : view.user,
 		revision: view.revision,
 		writable: settings.writable,
 		mode: "host",
@@ -16408,7 +17048,7 @@ function mutablePath(namespace, path) {
 	if (path.length === 4 && path[0] === "memoryTopology" && path[1] === "layers" && path[3] === "enabled") return MEMORY_LAYER_ID.test(path[2]);
 	return INTERACTION_PATHS.some((allowed) => allowed.length === path.length && allowed.every((segment, index) => segment === path[index]));
 }
-function createSettingsHandler(settings) {
+function createSettingsHandler(settings, credentials) {
 	return async (endpoint, rawPayload) => {
 		let namespace = MNEMON_SETTINGS_NAMESPACE;
 		try {
@@ -16435,7 +17075,13 @@ function createSettingsHandler(settings) {
 				};
 			});
 			const revision = payload.expectedRevision === void 0 ? void 0 : Number(payload.expectedRevision);
-			await settings.mutate(namespace, ops, revision);
+			const prepared = await prepareEmbeddingSettings(settings, namespace, ops, revision, credentials);
+			try {
+				await settings.mutate(namespace, prepared.operations, prepared.revision);
+			} catch (error) {
+				await prepared.rollback?.().catch(() => {});
+				throw error;
+			}
 			if (namespace === "mnemon") await migrateLegacyDisplayMode(settings);
 			return success(descriptor(settings, namespace));
 		} catch (error) {
@@ -16443,8 +17089,8 @@ function createSettingsHandler(settings) {
 		}
 	};
 }
-function registerSettingsRpc(connection, settings) {
-	const handler = createSettingsHandler(settings);
+function registerSettingsRpc(connection, settings, credentials) {
+	const handler = createSettingsHandler(settings, credentials);
 	connection.rpc.handle(MNEMON_SETTINGS_CHANNEL, handler);
 	return handler;
 }
@@ -19486,9 +20132,11 @@ function apply(rawContext, rawConfig = {}) {
 	const skills = new SkillEvolution({
 		settings: () => skillSettings.get(),
 		source: (agent) => skillsSourceFor(runtime, agent),
+		taskRoute: (workspace) => lifecycle.skillTaskRoute(workspace),
 		runTask: (workspaceRoot, signal, operation, route) => lifecycle.runSkillTask(workspaceRoot, signal, operation, route),
 		skillTask: (parent, label, prompt, schema, persona, signal, _route, maxTokens) => coordinator.skillTask(parent, label, prompt, schema, persona, signal, taskRoute(parent), maxTokens)
 	});
+	ctx.effect(() => hostSettings.onUpdated(() => skills.settingsChanged()), "dsh-mnemon: automatic skill adoption settings");
 	lifecycle.useSkillEvolution(skills);
 	ctx.effect(() => {
 		const stop = autoBackup.start();
@@ -19527,7 +20175,7 @@ function apply(rawContext, rawConfig = {}) {
 			pluginCommand: () => dshPluginCommand(ctx.get("profileContext"))
 		});
 		const rpc = registerRpc(connection, runtime, lifecycle, versions, () => autoBackup.refresh(), () => hasNativeDirectoryPicker(ctx));
-		const settings = registerSettingsRpc(connection, hostSettings);
+		const settings = registerSettingsRpc(connection, hostSettings, () => ctx.get("credentials") ?? ctx.credentials);
 		const view = registerViewRpc(connection, runtime, extensions, memoryPlugins, lifecycle, pluginInstallation);
 		if (Context.is(webContext)) new MnemonRemoteService(webContext, {
 			...rpc,