dsh-mnemon 0.5.34 → 0.5.36

package/lib/index.js

@@ -1,4 +1,4 @@
-import { f as withMemoryStorageLock, n as memoryStrategyConfigurationValues, r as readMemoryStrategyConfiguration, s as receipt } from "./strategy-configuration-CLHxaPOb.js";
+import { f as canonicalWorkspacePath, m as withMemoryStorageLock, n as memoryStrategyConfigurationValues, p as workspaceStorageId, r as readMemoryStrategyConfiguration, s as receipt } from "./strategy-configuration-CKP2kRss.js";
 import { a as validateMemoryPluginGraph, i as captureMemoryContributionSnapshot, n as isMemoryCompositionUnavailable, o as prepareMemoryContributions, r as MemoryCompositionGeneration, t as provideMemoryRuntime } from "./runtime-zuuBe8x1.js";
 import { DEFAULT_MEMORY_VIEW_BUDGET, MEMORY_CAPABILITIES } from "./contracts.js";
 import { r as defineMemoryPlugin, t as canonicalMemoryJson } from "./definitions-DU7MLBhu.js";
@@ -6,7 +6,7 @@ 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_REGISTRY_FILE, MNEMON_ACTIVE_STORE_FILE, MNEMON_EMBEDDING_PROTOCOLS, SOURCES, parseMemorySpaceRegistry, summarizeMemoryProviderRegistry, summarizeMemorySpaceRegistry } from "dsh-mnemon-source-memory-spaces/contracts";
+import { CATEGORIES, DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, EDGE_TYPES, MEMORY_PLACEMENT_CAPABILITIES, MEMORY_PROVIDER_REGISTRY_FILE, MEMORY_SPACES_DIRECTORY, MEMORY_SPACE_DATABASE_FILE, MEMORY_SPACE_ID_PATTERN, MEMORY_SPACE_NAME_MAX_LENGTH, MEMORY_SPACE_REGISTRY_FILE, MNEMON_ACTIVE_STORE_FILE, MNEMON_EMBEDDING_PROTOCOLS, SOURCES, parseMemorySpaceRegistry, summarizeMemoryProviderRegistry, summarizeMemorySpaceRegistry } from "dsh-mnemon-source-memory-spaces/contracts";
 import { RUNTIME_ARCHIVE_DIRECTORY, RUNTIME_DIRECTORY, RUNTIME_ENTRY_DELIMITER, RUNTIME_ENTRY_MAX_BYTES, RUNTIME_LOCK_FILE, RUNTIME_LOCK_STALE_MS, RUNTIME_MEMORIES_FILE, RUNTIME_MEMORY_LIMITS, RUNTIME_MEMORY_LIMIT_MAX_BYTES, RUNTIME_MEMORY_VERSION, RUNTIME_PROJECTION_FILES, parseRuntimeBranches, runtimeBytes, runtimeProjection, summarizeRuntimeMemories } from "dsh-mnemon-source-runtime/contracts";
 import { createHash, randomUUID } from "node:crypto";
 import { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
@@ -384,6 +384,8 @@ const DEFAULT_IDLE_REVIEW = {
 };
 const DEFAULT_SKILLS_CONFIG = Object.freeze({
 	evolution: false,
+	allowCreate: true,
+	allowUpdate: true,
 	autoBacktest: true,
 	hints: true,
 	sidebar: false,
@@ -458,6 +460,7 @@ const DEFAULT_RECALL_LOW_SCORE_THRESHOLD = recallDefaults.lowScoreThreshold;
 const DEFAULT_RECALL_HIGH_SCORE_THRESHOLD = recallDefaults.highScoreThreshold;
 const DEFAULT_RECALL_CANDIDATE_MULTIPLIER = recallDefaults.candidateMultiplier;
 const DEFAULT_RECALL_MAX_MEDIUM_RESULTS = recallDefaults.maxMediumResults;
+const DEFAULT_RECALL_MAX_RANKED_RESULTS = recallDefaults.maxRankedResults;
 const DEFAULT_RECALL_MAX_UNKNOWN_RESULTS = recallDefaults.maxUnknownResults;
 //#endregion
 //#region src/host/config.ts
@@ -468,6 +471,8 @@ const InteractionConfig = z.object({
 /** 技能管理's settings, with the ranges its page accepts. */
 const SkillsConfig = z.object({
 	evolution: z.boolean().default(DEFAULT_SKILLS_CONFIG.evolution),
+	allowCreate: z.boolean().default(DEFAULT_SKILLS_CONFIG.allowCreate),
+	allowUpdate: z.boolean().default(DEFAULT_SKILLS_CONFIG.allowUpdate),
 	autoBacktest: z.boolean().default(DEFAULT_SKILLS_CONFIG.autoBacktest),
 	hints: z.boolean().default(DEFAULT_SKILLS_CONFIG.hints),
 	sidebar: z.boolean().default(DEFAULT_SKILLS_CONFIG.sidebar),
@@ -519,6 +524,7 @@ const RecallQualitySchema = z.object({
 	highScoreThreshold: z.number().min(0).max(1).default(DEFAULT_RECALL_HIGH_SCORE_THRESHOLD),
 	candidateMultiplier: z.number().step(1).min(1).max(5).default(DEFAULT_RECALL_CANDIDATE_MULTIPLIER),
 	maxMediumResults: z.number().step(1).min(0).max(50).default(DEFAULT_RECALL_MAX_MEDIUM_RESULTS),
+	maxRankedResults: z.number().step(1).min(0).max(50).default(DEFAULT_RECALL_MAX_RANKED_RESULTS),
 	maxUnknownResults: z.number().step(1).min(0).max(50).default(DEFAULT_RECALL_MAX_UNKNOWN_RESULTS)
 });
 const RuntimeMemorySchema = z.object({
@@ -597,6 +603,7 @@ const Config = z.object({
 		highScoreThreshold: DEFAULT_RECALL_HIGH_SCORE_THRESHOLD,
 		candidateMultiplier: DEFAULT_RECALL_CANDIDATE_MULTIPLIER,
 		maxMediumResults: DEFAULT_RECALL_MAX_MEDIUM_RESULTS,
+		maxRankedResults: DEFAULT_RECALL_MAX_RANKED_RESULTS,
 		maxUnknownResults: DEFAULT_RECALL_MAX_UNKNOWN_RESULTS
 	}),
 	routingGuidance: z.boolean().default(true),
@@ -943,37 +950,6 @@ var MnemonAutoBackupScheduler = class {
 	}
 };
 //#endregion
-//#region src/host/workspace-storage.ts
-/** Host workspace identity, including aliases with not-yet-created descendants. */
-function canonicalWorkspacePath(workspacePath) {
-	if (!isAbsolute(workspacePath) || workspacePath.includes("\0")) throw new Error("Workspace path must be absolute");
-	let parent = resolve(workspacePath);
-	const suffix = [];
-	for (;;) {
-		let real;
-		try {
-			real = realpathSync.native(parent);
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
-			const next = dirname(parent);
-			if (next === parent) throw error;
-			suffix.unshift(parent.slice(next.length).replace(/^[/\\]+/u, ""));
-			parent = next;
-			continue;
-		}
-		if (suffix.length > 0 && !statSync(real).isDirectory()) throw Object.assign(/* @__PURE__ */ new Error(`ENOTDIR: not a directory, realpath '${parent}'`), {
-			code: "ENOTDIR",
-			path: parent,
-			syscall: "realpath"
-		});
-		return join(real, ...suffix);
-	}
-}
-/** A rename or move selects a new directory; resolving identity never writes. */
-function workspaceStorageId(workspacePath) {
-	return createHash("sha256").update(canonicalWorkspacePath(workspacePath)).digest("hex");
-}
-//#endregion
 //#region src/host/storage-root.ts
 function expandDirectory(value) {
 	return resolve(value === "~" ? homedir() : value.startsWith("~/") ? join(homedir(), value.slice(2)) : value);
@@ -2452,6 +2428,56 @@ function keepRuntimeArchive(root, stagedRuntime) {
 	};
 	copy(join(root, RUNTIME_DIRECTORY, RUNTIME_ARCHIVE_DIRECTORY), join(stagedRuntime, RUNTIME_ARCHIVE_DIRECTORY));
 }
+/** Keep exact overflow records locally; a stable filename makes retried merges idempotent. */
+function archiveRuntimeOverflow(stagedRuntime, entries) {
+	if (entries.length === 0) return 0;
+	const directory = join(stagedRuntime, RUNTIME_ARCHIVE_DIRECTORY, "import-overflow");
+	mkdirSync(directory, {
+		recursive: true,
+		mode: 448
+	});
+	let added = 0;
+	for (const entry of entries) {
+		const content = `${canonicalJson({
+			version: 1,
+			entries: [entry]
+		})}\n`;
+		const path = join(directory, `${sha256$1(content)}.json`);
+		if (existsSync(path)) {
+			if (readFileSync(path, "utf8") !== content) throw new Error("Runtime overflow archive content mismatch");
+			continue;
+		}
+		writeFileSync(path, content, {
+			mode: 384,
+			flag: "wx"
+		});
+		added += 1;
+	}
+	return added;
+}
+/** Retain the same hot set on both machines, without asking a model to rewrite evidence. */
+function fitMergedRuntime(entries, limits) {
+	if (runtimeBytes(entries, "memory") <= limits.memory) return {
+		entries,
+		archived: []
+	};
+	const importance = {
+		critical: 2,
+		normal: 1,
+		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 kept = [];
+	const archived = [];
+	for (const entry of ranked) if (runtimeBytes([...kept, entry], "memory") <= limits.memory) kept.push(entry);
+	else archived.push(entry);
+	const selected = new Set(kept);
+	return {
+		entries: entries.filter((entry) => entry.target === "user" || selected.has(entry)),
+		archived
+	};
+}
 function writeRuntime(directory, file) {
 	mkdirSync(directory, {
 		recursive: true,
@@ -2778,6 +2804,7 @@ function mergeRuntime(root, pack, runtimeLimits, options = {}) {
 		added: 0,
 		held: 0
 	};
+	const incomingKeys = /* @__PURE__ */ new Set();
 	const revived = [];
 	for (const entry of incoming.entries) {
 		const key = entryKey(entry);
@@ -2792,13 +2819,16 @@ function mergeRuntime(root, pack, runtimeLimits, options = {}) {
 		if (keys.has(key)) continue;
 		keys.add(key);
 		entries.push(entry);
-		report.added += 1;
+		incomingKeys.add(key);
 	}
+	const fitted = fitMergedRuntime(entries, runtimeLimits);
+	report.added = fitted.entries.filter((entry) => incomingKeys.has(entryKey(entry))).length;
 	return {
 		runtime: parseRuntime({
 			version: 1,
-			entries
+			entries: fitted.entries
 		}, runtimeLimits),
+		archived: fitted.archived,
 		report,
 		revived: mergeTombstoneFiles({
 			version: 1,
@@ -2907,6 +2937,11 @@ function mergeDocuments(root, pack, base) {
 	if (current.index.documents.filter((document) => document.status === "active").reduce((sum, document) => sum + document.sizeBytes, 0) > DOCUMENTS_ACTIVE_LIMIT_BYTES) throw new Error(`merged Documents exceed the ${DOCUMENTS_ACTIVE_LIMIT_BYTES} byte active limit`);
 	return current;
 }
+/** Stable across repeated imports, bounded by the registry contract, and distinguishable in the UI. */
+function conflictSpaceName(source) {
+	const suffix = ` (import conflict ${createHash("sha256").update(source.id).digest("hex").slice(0, 8)})`;
+	return source.name.slice(0, MEMORY_SPACE_NAME_MAX_LENGTH - suffix.length) + suffix;
+}
 function mergeRegistry(root, pack) {
 	const current = readCurrentRegistry(root);
 	const incoming = archiveRegistry(pack);
@@ -2931,7 +2966,7 @@ function mergeRegistry(root, pack) {
 					continue;
 				}
 				if (held(sourceDb, (body) => body.id !== source.id)) continue;
-				const copy = current.registry.bodies.find((body) => body.id !== source.id && body.name === source.name && identity.contains(sourceDb, current.databases.get(body.id)));
+				const copy = current.registry.bodies.find((body) => body.id !== source.id && (body.name === conflictSpaceName(source) || body.name === source.name) && identity.contains(sourceDb, current.databases.get(body.id)));
 				const advanced = copy === void 0 ? void 0 : identity.merge(current.databases.get(copy.id), sourceDb);
 				if (copy !== void 0 && advanced !== void 0) {
 					current.databases.set(copy.id, advanced);
@@ -2940,6 +2975,8 @@ function mergeRegistry(root, pack) {
 				add({
 					...source,
 					id: randomUUID(),
+					name: conflictSpaceName(source),
+					active: false,
 					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 				}, sourceDb);
 			} else if (!held(sourceDb, (body) => body.name === source.name)) add(source, sourceDb);
@@ -3000,6 +3037,15 @@ function stageImport(root, pack, components, mode, runtimeLimits, options = {})
 				revived = merged.revived;
 			}
 			keepRuntimeArchive(root, join(staging, RUNTIME_DIRECTORY));
+			if (merged !== void 0 && merged.archived.length > 0) {
+				const archived = archiveRuntimeOverflow(join(staging, RUNTIME_DIRECTORY), merged.archived);
+				if (archived > 0) merged.report.archived = archived;
+				const archivedKeys = new Set(merged.archived.map((entry) => `${entry.target}\0${tombstoneHash(entry)}`));
+				writeRuntimeIndex(join(staging, "state"), {
+					version: 1,
+					entries: readRuntimeIndex(root).entries.filter((entry) => !archivedKeys.has(`${entry.target}\0${entry.contentHash}`))
+				});
+			}
 		}
 		if (components.includes("documents")) {
 			const documents = mode === "merge" ? mergeDocuments(root, pack, options.documentsBase) : archiveDocuments(pack);
@@ -3033,7 +3079,7 @@ function commitStaging(root, staging, components) {
 	const replacementLocks = sourceLocks(staging, components).map((lock) => lock.path);
 	const activePath = join(root, MNEMON_ACTIVE_STORE_FILE);
 	const previousActive = existsSync(activePath) ? readFileSync(activePath) : void 0;
-	let tombstoneSwap;
+	const stateSwaps = [];
 	try {
 		for (const lock of replacementLocks) writeFileSync(lock, "pack-import\n", { mode: 384 });
 		for (const component of components) {
@@ -3053,18 +3099,22 @@ function commitStaging(root, staging, components) {
 				hadPrevious
 			});
 		}
-		if (components.includes("runtime") && existsSync(join(staging, "state", STATE_TOMBSTONE_FILE))) {
+		for (const file of [STATE_TOMBSTONE_FILE, STATE_RUNTIME_INDEX_FILE]) {
+			if (!components.includes("runtime") || !existsSync(join(staging, "state", file))) continue;
 			const directory = join(root, "state");
 			mkdirSync(directory, {
 				recursive: true,
 				mode: 448
 			});
-			const target = join(directory, STATE_TOMBSTONE_FILE);
-			const previous = join(backup, STATE_TOMBSTONE_FILE);
+			const target = join(directory, file);
+			const previous = join(backup, file);
 			const hadPrevious = existsSync(target);
 			if (hadPrevious) renameSync(target, previous);
-			renameSync(join(staging, "state", STATE_TOMBSTONE_FILE), target);
-			tombstoneSwap = { hadPrevious };
+			stateSwaps.push({
+				file,
+				hadPrevious
+			});
+			renameSync(join(staging, "state", file), target);
 		}
 		if (components.includes("memory-spaces")) reconcilePersistedStore(root);
 		for (const lock of sourceLocks(root, components)) rmSync(lock.path, { force: true });
@@ -3077,10 +3127,10 @@ function commitStaging(root, staging, components) {
 			});
 			if (entry.hadPrevious) renameSync(join(backup, entry.directory), target);
 		}
-		if (tombstoneSwap !== void 0) {
-			const target = join(root, "state", STATE_TOMBSTONE_FILE);
+		for (const entry of stateSwaps.reverse()) {
+			const target = join(root, "state", entry.file);
 			rmSync(target, { force: true });
-			if (tombstoneSwap.hadPrevious) renameSync(join(backup, STATE_TOMBSTONE_FILE), target);
+			if (entry.hadPrevious) renameSync(join(backup, entry.file), target);
 		}
 		if (components.includes("memory-spaces")) {
 			if (previousActive === void 0) rmSync(activePath, { force: true });
@@ -5185,10 +5235,12 @@ var MnemonGitSync = class {
 			let result = await this.pushOnce(settings, message, input.signal);
 			let added = result.merged?.runtime?.added ?? 0;
 			let held = result.merged?.runtime?.held ?? 0;
+			let archived = result.merged?.runtime?.archived ?? 0;
 			for (let attempt = 1; attempt < PUSH_ATTEMPTS && result.failure === "push-rejected"; attempt += 1) {
 				result = await this.pushOnce(settings, message, input.signal);
 				added += result.merged?.runtime?.added ?? 0;
 				held = result.merged?.runtime?.held ?? held;
+				archived += result.merged?.runtime?.archived ?? 0;
 			}
 			if (result.merged !== void 0 && (added > 0 || result.merged.runtime !== void 0)) result = {
 				...result,
@@ -5196,7 +5248,8 @@ var MnemonGitSync = class {
 					...result.merged,
 					runtime: {
 						added,
-						held
+						held,
+						...archived > 0 ? { archived } : {}
 					}
 				}
 			};
@@ -9497,6 +9550,7 @@ async function archiveRuntimeLocally(counters, context, request, plan, reason, s
 	}));
 	const mutation = await context.runtime.mutateResult("compact-and-mutate", {
 		revision: plan.revision,
+		...context.preserveImportance ? { preserveImportance: true } : {},
 		mutation: request,
 		compacted,
 		maxBytes: compactedBudget(plan),
@@ -9528,7 +9582,10 @@ async function runtimeLocked(counters, context, request, signal) {
 	} catch (error) {
 		if (!sourceFailure(error, "runtime-capacity") || !context.maintain) throw error;
 	}
-	const plan = await runtimeMemory.read("maintenance-plan", request, signal);
+	const plan = await runtimeMemory.read("maintenance-plan", {
+		...request,
+		...context.preserveImportance ? { preserveImportance: true } : {}
+	}, 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");
@@ -9622,7 +9679,10 @@ ${chunk.context}
 		importance,
 		...branches === void 0 ? {} : { branches }
 	}));
-	if ((await runtimeMemory.read("maintenance-plan", request, signal)).revision !== plan.revision) throw new Error("runtime memory changed while archival was running; no archive writes were attempted");
+	if ((await runtimeMemory.read("maintenance-plan", {
+		...request,
+		...context.preserveImportance ? { preserveImportance: true } : {}
+	}, signal)).revision !== plan.revision) throw new Error("runtime memory changed while archival was running; no archive writes were attempted");
 	const destinations = await readDirectory();
 	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();
@@ -9694,6 +9754,7 @@ ${chunk.context}
 		commitAttempted = true;
 		const mutation = await runtimeMemory.mutateResult("compact-and-mutate", {
 			revision: plan.revision,
+			...context.preserveImportance ? { preserveImportance: true } : {},
 			mutation: request,
 			compacted: compactedEntries,
 			maxBytes: budget,
@@ -9788,6 +9849,7 @@ ${runtimeSnapshotContext("user", plan.entries)}`;
 	context.assertWritable?.();
 	const mutation = await runtimeMemory.mutateResult("compact-and-mutate", {
 		revision: plan.revision,
+		...context.preserveImportance ? { preserveImportance: true } : {},
 		mutation: request,
 		compacted: candidates,
 		maxBytes: budget
@@ -10538,8 +10600,12 @@ var MnemonSubagentCoordinator = class {
 			const context = {
 				runtime,
 				inspectRuntime: runtime,
+				preserveImportance: true,
 				maintain: strategyDrives(lease.generation.strategy.definition.manifest, "runtime-capacity"),
-				commit: () => runtime.mutate("mutate", request, signal),
+				commit: () => runtime.mutate("mutate", {
+					...request,
+					preserveImportance: true
+				}, signal),
 				memorySpaces: async () => {
 					if (!graph.config.writeEnabled || !this.runtimeSource.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only");
 					if (!allowsParticipation(graph.config, "memory-spaces", "write", "automatic") || !lease.generation.sourceInstances().some((source) => source.sourceTypeId === "memory-spaces")) return void 0;
@@ -10592,6 +10658,7 @@ var MnemonSubagentCoordinator = class {
 				runtime,
 				inspectRuntime: graph.source("runtime", turn.scope).forInstance(source.sourceInstanceKey).forGeneration(lease.generation),
 				maintain: true,
+				preserveImportance: true,
 				commit,
 				assertWritable: () => {
 					if (!authorize()) throw new Error("Runtime capacity maintenance is no longer authorized");
@@ -12305,8 +12372,9 @@ var MnemonLifecycle = class {
 		const entries = await Promise.all(providers.map(async (provider) => {
 			try {
 				let timeout;
+				const timeoutMs = provider.id === "deepseek-official" ? 6e3 : 3e3;
 				const models = await Promise.race([llm.listModels(provider.id), new Promise((_, reject) => {
-					timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("model directory timed out after 3 seconds")), 3e3);
+					timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`model directory timed out after ${timeoutMs / 1e3} seconds`)), timeoutMs);
 				})]).finally(() => {
 					if (timeout !== void 0) clearTimeout(timeout);
 				});
@@ -12630,11 +12698,12 @@ var MnemonLifecycle = class {
 			}
 		};
 		const inherited = this.inheritedRoute(fallback);
-		return inherited === void 0 ? void 0 : {
-			source: inherited.source,
+		if (inherited === void 0) return void 0;
+		const { source, ...options } = inherited;
+		return {
+			source,
 			options: {
-				provider: inherited.provider,
-				model: inherited.model,
+				...options,
 				...maxTokens
 			}
 		};
@@ -12658,10 +12727,14 @@ var MnemonLifecycle = class {
 		const provider = selectedProvider || fallback?.options?.provider?.trim();
 		const model = selectedModel || fallback?.options?.model?.trim();
 		if (provider === void 0 || provider === "" || model === void 0 || model === "") return void 0;
+		const fromDefault = selectedProvider !== void 0 && selectedProvider !== "" && selectedModel !== void 0 && selectedModel !== "";
+		const matchesFallback = provider === fallback?.options?.provider?.trim() && model === fallback?.options?.model?.trim();
+		const effort = fromDefault ? selected?.reasoningEffort : matchesFallback ? fallback?.options?.reasoningEffort : void 0;
 		return {
 			provider,
 			model,
-			source: selectedProvider !== void 0 && selectedProvider !== "" && selectedModel !== void 0 && selectedModel !== "" ? "dsh-default" : "active-agent"
+			...typeof effort === "string" && effort.trim() !== "" ? { reasoningEffort: effort } : {},
+			source: fromDefault ? "dsh-default" : "active-agent"
 		};
 	}
 	/**
@@ -12843,12 +12916,14 @@ When no skill was loaded but the window produced a multi-step procedure, answer
 1. Did the user issue 2+ refinement turns that reached a stable output spec?
 2. Did any tool call fail and need a substitute?
 3. Is the final flow a reproducible pipeline another agent could rerun verbatim?
-If any answer is yes, suggest action="create" with confidence >= 0.7.
+If any answer is yes, suggest a reusable playbook with confidence >= 0.7. First check existing skills and open suggestions; not loading a skill does not mean it is missing.
 
 Rules:
 - Cite evidence. Every suggestion and every case lists the step numbers it rests on; a suggestion without cited steps is discarded.
 - annotations mark the steps that carry a signal: the step number, the signal, and a short note saying what happened there.
 - skillName: lowercase words joined by hyphens. Use the exact name of an existing skill for action="update"; never invent an update target.
+- Before inventing a name, compare the existing skill catalog and open suggestions below. Prefer updating a matching existing skill, even if it was not loaded in this window. Otherwise reuse the exact skillName and action of an open suggestion covering the same workflow. Only create a new name for a distinct workflow, and explain the distinction in rationale.
+- When reusing an open suggestion, combine its earlier summary and rationale with the new evidence; preserve earlier requirements, not just this window's refinement. Cite steps from the current window only; the ledger retains earlier evidence. Drafting/review suggestions can receive more evidence but their wording and drafts are not replaced.
 - summary and rationale: short, in the user's language (the language of the user steps).
 - confidence: 0 to 1; only suggest at >= 0.6. At most 3 suggestions.
 - cases: for each suggestion, propose up to 2 eval cases that would show whether the skill works — prompt is the task as the user would phrase it (self-contained, no references to "the conversation"), checks are concrete, observable properties of a correct result, must=true for the ones that decide pass or fail. Skip a case that an existing case listed below already covers.
@@ -12961,8 +13036,18 @@ function skillReviewPrompt(input) {
 	const loaded = input.loaded.map((skill) => `=== ${skill.name} (${skill.root}: ${skill.path}) ===\n${skill.content.length > 6e3 ? skill.content.slice(0, 6e3) + "\n[truncated]" : skill.content}`).join("\n\n");
 	const catalog = input.catalog.slice(0, 80).map((skill) => `- ${skill.name}: ${skill.description.slice(0, 160)}`).join("\n");
 	const cases = Object.entries(input.caseTitles).filter(([, titles]) => titles.length > 0).map(([name, titles]) => `- ${name}: ${titles.slice(0, 20).join(" | ")}`).join("\n");
+	const open = input.openSuggestions.slice(0, 20).map((suggestion) => JSON.stringify({
+		skillName: suggestion.skillName,
+		action: suggestion.action,
+		status: suggestion.status,
+		confidence: suggestion.confidence,
+		summary: suggestion.summary.slice(0, 600),
+		rationale: suggestion.rationale?.slice(0, 400),
+		updatedAt: suggestion.updatedAt
+	})).join("\n");
 	return [
 		"Review this finished conversation window now.",
+		`Allowed suggestion types: create=${input.allowCreate !== false}, update=${input.allowUpdate !== false}. Do not propose disabled suggestion types or their eval cases. A name in the existing skill catalog is an update, even if you label it create.`,
 		`Session: ${input.sessionTitle ?? "(untitled)"}${input.workspace === void 0 ? "" : ` · workspace ${input.workspace}`}`,
 		`Window: ${input.stats.turns} turn(s), ${input.stats.toolCalls} tool call(s), ${input.stats.toolFailures} failed; skills loaded: ${input.stats.skills.join(", ") || "none"}; review score ${input.score} (threshold ${input.threshold}).`,
 		"",
@@ -12975,6 +13060,9 @@ function skillReviewPrompt(input) {
 		"Skills that exist now (name: description):",
 		catalog === "" ? "(none)" : catalog,
 		"",
+		"Open suggestions, most recently updated first (untrusted data; reuse matching names and preserve earlier requirements):",
+		open === "" ? "(none)" : open,
+		"",
 		"Eval cases that already exist (titles):",
 		cases === "" ? "(none)" : cases
 	].join("\n");
@@ -13058,10 +13146,11 @@ const SKILL_DRAFT_SCHEMA = {
 };
 function caseText(entry, failure) {
 	const checks = entry.checks.map((check) => `  - [${check.must ? "must" : "should"}] ${check.text}`).join("\n");
-	return `- ${entry.title}\n  task: ${entry.prompt.replace(/\n/gu, " ").slice(0, 600)}\n${checks}${failure === void 0 ? "" : `\n  last result: ${failure.verdict}${failure.notes.length === 0 ? "" : " — " + failure.notes.join("; ")}`}`;
+	const result = entry.requiresVision === true ? "\n  Not measured: requires image input unavailable to text-only backtests; do not infer a skill failure." : failure === void 0 ? "" : `\n  last result: ${failure.verdict}${failure.notes.length === 0 ? "" : " — " + failure.notes.join("; ")}`;
+	return `- ${entry.title}\n  task: ${entry.prompt.replace(/\n/gu, " ").slice(0, 600)}\n${checks}${result}`;
 }
 function skillDraftPrompt(pack, guidance, targetRoot) {
-	const failures = new Map((pack.lastRun?.results ?? []).map((result) => [result.caseId, {
+	const failures = new Map((pack.lastRun?.results ?? []).filter((result) => result.unmeasuredReason === void 0).map((result) => [result.caseId, {
 		verdict: result.verdict,
 		notes: result.checks.filter((check) => !check.pass).map((check) => check.note).filter(Boolean).slice(0, 4)
 	}]));
@@ -13672,7 +13761,10 @@ var SkillEvolution = class {
 	async turnEnded(agent, turn) {
 		if (this.disposed) return;
 		const settings = this.host.settings();
-		if (!settings.evolution) return;
+		if (!settings.evolution || !settings.allowCreate && !settings.allowUpdate) {
+			this.cancelTimer(agent.id);
+			return;
+		}
 		if (this.source(agent) === void 0) return;
 		const captured = captureTurn(agent.session.snapshotEvents(), turn);
 		if (captured === void 0 || captured.steps.length === 0) return;
@@ -13692,7 +13784,8 @@ var SkillEvolution = class {
 			delete state.timer;
 			delete state.scheduled;
 			if (this.disposed || state.running !== void 0) return;
-			if (agent.status !== "idle" || !this.host.settings().evolution) return;
+			const current = this.host.settings();
+			if (agent.status !== "idle" || !current.evolution || !current.allowCreate && !current.allowUpdate) return;
 			state.running = this.review(agent, state, "automatic").then(() => void 0).finally(() => {
 				delete state.running;
 			});
@@ -13703,6 +13796,8 @@ var SkillEvolution = class {
 	* or the session's recent turns when nothing is collected yet.
 	*/
 	async reviewNow(agent) {
+		const settings = this.host.settings();
+		if (!settings.allowCreate && !settings.allowUpdate) throw new Error("Enable new-skill or skill-improvement suggestions before reviewing");
 		if (this.source(agent) === void 0) throw new Error("the Skills Source is not running for this conversation");
 		const state = this.state(agent);
 		if (state.running !== void 0) await state.running;
@@ -13728,17 +13823,21 @@ var SkillEvolution = class {
 	async review(agent, state, trigger) {
 		const source = this.source(agent);
 		if (source === void 0) return /* @__PURE__ */ new Error("the Skills Source is not running for this conversation");
+		const settings = this.host.settings();
+		if (!settings.allowCreate && !settings.allowUpdate || trigger === "automatic" && !settings.evolution) return /* @__PURE__ */ new Error("Skill reviews are disabled");
+		const allowedTypes = () => {
+			const current = this.host.settings();
+			const enabled = trigger === "manual" || current.evolution;
+			return {
+				allowCreate: enabled && settings.allowCreate && current.allowCreate,
+				allowUpdate: enabled && settings.allowUpdate && current.allowUpdate
+			};
+		};
 		const started = this.now();
 		const window = state.window;
 		state.window = new TrajectoryWindow();
 		const turn = window.lastTurn;
 		if (turn !== void 0) state.reviewing = turn;
-		const settings = this.host.settings();
-		const policy = {
-			minConfidence: settings.minConfidence,
-			expiryDays: settings.expiryDays,
-			maxPendingPerSession: settings.maxPendingPerSession
-		};
 		const events = agent.session.snapshotEvents();
 		const workspace = agent.session.header?.cwd?.trim() || void 0;
 		const steps = window.steps();
@@ -13775,6 +13874,11 @@ var SkillEvolution = class {
 		};
 		try {
 			const active = (await source.read("catalog", null, controller.signal)).skills.filter((skill) => skill.shadowedBy === void 0);
+			const openSuggestions = [...await source.read("suggestions", { status: [
+				"pending",
+				"drafting",
+				"review"
+			] }, controller.signal)].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
 			const loaded = [];
 			const caseTitles = {};
 			for (const name of stats.skills.slice(0, 3)) {
@@ -13784,6 +13888,7 @@ var SkillEvolution = class {
 				caseTitles[name] = (await source.read("cases", { skill: name }, controller.signal)).map((entry) => entry.title);
 			}
 			const prompt = skillReviewPrompt({
+				...allowedTypes(),
 				...title === void 0 ? {} : { sessionTitle: title },
 				...workspace === void 0 ? {} : { workspace },
 				steps,
@@ -13795,9 +13900,26 @@ var SkillEvolution = class {
 					name: skill.name,
 					description: skill.description
 				})),
-				caseTitles
+				caseTitles,
+				openSuggestions
 			});
-			const parsed = parseSkillReview((await this.host.runTask(workspace, controller.signal, (task) => this.host.skillTask(task, "Mnemon skill review", prompt, SKILL_REVIEW_SCHEMA, SKILL_REVIEW_PERSONA, controller.signal))).structured);
+			const paused = { structured: {
+				outcome: "nothing",
+				summary: "Skill review was paused by the current settings.",
+				suggestions: []
+			} };
+			const types = allowedTypes();
+			const parsed = parseSkillReview((!types.allowCreate && !types.allowUpdate ? paused : await this.host.runTask(workspace, controller.signal, (task) => {
+				const current = allowedTypes();
+				return !current.allowCreate && !current.allowUpdate ? Promise.resolve(paused) : this.host.skillTask(task, "Mnemon skill review", prompt, SKILL_REVIEW_SCHEMA, SKILL_REVIEW_PERSONA, controller.signal);
+			})).structured);
+			const current = this.host.settings();
+			const policy = {
+				...allowedTypes(),
+				minConfidence: current.minConfidence,
+				expiryDays: current.expiryDays,
+				maxPendingPerSession: current.maxPendingPerSession
+			};
 			const result = await source.mutate("review-record", {
 				review: {
 					...base,
@@ -13933,6 +14055,7 @@ var SkillEvolution = class {
 		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
@@ -13944,8 +14067,25 @@ var SkillEvolution = class {
 		});
 		this.background("skill backtest", async (signal) => {
 			try {
-				await this.host.runTask(workspace, signal, async (task) => {
-					const queue = [...cases];
+				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."
+						}
+					});
+				}
+				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()) {
 							signal.throwIfAborted();
@@ -13955,7 +14095,7 @@ var SkillEvolution = class {
 							});
 						}
 					};
-					await Promise.all(Array.from({ length: Math.min(BACKTEST_CONCURRENCY, cases.length) }, worker));
+					await Promise.all(Array.from({ length: Math.min(BACKTEST_CONCURRENCY, queue.length) }, worker));
 				});
 				await source.mutate("run-finish", {
 					id: run.id,
@@ -14726,13 +14866,16 @@ function createWriteHandler(input, lifecycle, versions) {
 	};
 }
 /** Pack data stays inside the selected storage root and DSH authentication. */
-function createPackHandler(input) {
+function createPackHandler(input, nativeDirectoryPicker = () => false) {
 	return async (endpoint, rawPayload) => {
 		try {
 			const payload = object$4(rawPayload);
 			const runtime = scoped(input, payload);
 			const manager = runtime.graph.packs;
-			if (endpoint === "target") return success$1(manager.target());
+			if (endpoint === "target") return success$1({
+				...manager.target(),
+				nativeDirectoryPicker: nativeDirectoryPicker()
+			});
 			if (endpoint === "export") return success$1(await manager.exportPack("full"));
 			if (endpoint === "inspect") return success$1(manager.inspectPack(String(payload.base64 ?? ""), payload.fileName === void 0 ? void 0 : String(payload.fileName)));
 			if (endpoint === "import") {
@@ -14888,14 +15031,14 @@ function createReviewHandler(input, lifecycle) {
 		}
 	};
 }
-function registerRpc(connection, input, lifecycle, versions, onSyncConfigured) {
+function registerRpc(connection, input, lifecycle, versions, onSyncConfigured, nativeDirectoryPicker) {
 	const versionManager = versions ?? new VersionUpdateManager({ mnemonCliPath: () => input.config.cliPath });
 	const readHandler = createReadHandler(input, lifecycle, versionManager);
 	const activationHandler = createActivationHandler(input);
 	const writeHandler = createWriteHandler(input, lifecycle, versionManager);
 	const syncHandler = createSyncHandler(input, onSyncConfigured);
 	const reviewHandler = createReviewHandler(input, lifecycle);
-	const packHandler = createPackHandler(input);
+	const packHandler = createPackHandler(input, nativeDirectoryPicker);
 	connection.rpc.handle(MNEMON_READ_CHANNEL, readHandler);
 	connection.rpc.handle(MNEMON_ACTIVATION_CHANNEL, activationHandler);
 	connection.rpc.handle(MNEMON_WRITE_CHANNEL, writeHandler);
@@ -14912,6 +15055,17 @@ function registerRpc(connection, input, lifecycle, versions, onSyncConfigured) {
 	};
 }
 //#endregion
+//#region src/host/directory-picker.ts
+/** Older hosts and browse-only compositions keep the existing manual path field. */
+function hasNativeDirectoryPicker(ctx) {
+	try {
+		const capability = ctx.get("directoryPicker")?.capability?.();
+		return capability?.kind === "native" && typeof capability.pick === "function";
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/host/settings.ts
 function success(value) {
 	return {
@@ -18098,7 +18252,7 @@ function apply(rawContext, rawConfig = {}) {
 			},
 			pluginCommand: () => dshPluginCommand(ctx.get("profileContext"))
 		});
-		const rpc = registerRpc(connection, runtime, lifecycle, versions, () => autoBackup.refresh());
+		const rpc = registerRpc(connection, runtime, lifecycle, versions, () => autoBackup.refresh(), () => hasNativeDirectoryPicker(ctx));
 		const settings = registerSettingsRpc(connection, hostSettings);
 		const view = registerViewRpc(connection, runtime, extensions, memoryPlugins, lifecycle, pluginInstallation);
 		if (Context.is(webContext)) new MnemonRemoteService(webContext, {