dsh-mnemon 0.5.42 → 0.5.43

package/lib/index.js

@@ -7,7 +7,7 @@ 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 { 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,7 @@ const DEFAULT_SKILLS_CONFIG = Object.freeze({
 	allowUpdate: true,
 	targetScope: "user",
 	autoBacktest: true,
+	autoAdopt: false,
 	draftMaxTokens: 32768,
 	draftRetryMaxTokens: 65536,
 	hints: true,
@@ -483,6 +486,7 @@ 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),
 	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),
@@ -539,6 +543,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 +600,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 +725,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 +734,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 +2259,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 +2270,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 +2488,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 +2499,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 +2848,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);
@@ -9672,7 +9692,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) => ({
@@ -9721,10 +9745,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 +9792,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 +9829,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.
 
@@ -9851,11 +9878,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 +9893,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 +9938,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,11 +10005,13 @@ ${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);
 	if (value.action !== "compacted") throw new Error(typeof value.summary === "string" && value.summary !== "" ? value.summary : "USER.md compaction failed");
@@ -10010,17 +10040,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();
@@ -10357,9 +10391,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) {
@@ -10485,17 +10526,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 +10633,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,
@@ -13871,6 +13918,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 +14015,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 +14039,219 @@ 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);
+			await this.record(job, {
+				stage: "queued",
+				attempt
+			});
+			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: {
+							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 ? {} : { 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 +15084,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 +15092,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;
@@ -14863,8 +15153,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 +15402,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 +15433,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
@@ -15157,26 +15469,83 @@ 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.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 +15582,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 +15625,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 +15770,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 +15888,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();
@@ -15783,6 +16234,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 },
@@ -19486,9 +19938,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();