@lmzhen/dsh-evolution-core 0.1.0-rc.1

package/lib/index.js

@@ -0,0 +1,1456 @@
+import { dirname, join } from "node:path";
+import { cp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { createHash, randomBytes } from "node:crypto";
+import { homedir } from "node:os";
+import { readFileSync } from "node:fs";
+//#region lib/types/io.js
+/**
+* Structural IO seam for the legacy facade stores.
+*
+* The facade accepts any object exposing this small async file-tree surface.
+* Native DSH packages pass `ctx.evolutionIo.provider()`; standalone consumers
+* (and the facade's own tests) can use `nodeEvolutionIo`.
+*/
+/** Lazy adapter over an IO provider registry, shared by every evolution consumer. */
+function evolutionIoAdapter(provider) {
+	return {
+		readText: (path) => provider().readText(path),
+		writeText: (path, content) => provider().writeText(path, content),
+		remove: (path) => provider().remove(path),
+		list: (path) => provider().list(path),
+		exists: (path) => provider().exists(path),
+		rename: (path, destination) => provider().rename(path, destination),
+		copy: (path, destination) => provider().copy(path, destination)
+	};
+}
+function nodeEvolutionIo() {
+	return {
+		async readText(path) {
+			try {
+				return await readFile(path, "utf8");
+			} catch {
+				return null;
+			}
+		},
+		async writeText(path, content) {
+			await mkdir(dirname(path), { recursive: true });
+			const tmp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+			await writeFile(tmp, content, "utf8");
+			await rename(tmp, path);
+		},
+		async remove(path) {
+			await rm(path, {
+				recursive: true,
+				force: true
+			});
+		},
+		async list(path) {
+			try {
+				return await readdir(path);
+			} catch {
+				return [];
+			}
+		},
+		async exists(path) {
+			try {
+				await stat(path);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async rename(path, destination) {
+			await mkdir(dirname(destination), { recursive: true });
+			await rename(path, destination);
+		},
+		async copy(path, destination) {
+			await mkdir(dirname(destination), { recursive: true });
+			await cp(path, destination, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+/** Absolute path helper kept separate so stores stay platform-correct. */
+function childPath(parent, ...parts) {
+	return join(parent, ...parts);
+}
+//#endregion
+//#region lib/types/usage.js
+/**
+* Skill usage telemetry sidecar: `$DSH_HOME/skills/.usage.json`.
+* Format-compatible with Hermes Agent / hermes-claw core fields.
+*/
+function usageFile(root) {
+	return join(root, ".usage.json");
+}
+function emptyRecord() {
+	return {
+		created_by: null,
+		use_count: 0,
+		view_count: 0,
+		patch_count: 0,
+		last_used_at: null,
+		last_viewed_at: null,
+		last_patched_at: null,
+		created_at: (/* @__PURE__ */ new Date()).toISOString(),
+		state: "active",
+		pinned: false,
+		archived_at: null
+	};
+}
+async function loadUsage(root, io = nodeEvolutionIo()) {
+	const map = /* @__PURE__ */ new Map();
+	const raw = await io.readText(usageFile(root));
+	if (raw !== null) try {
+		const parsed = JSON.parse(raw);
+		for (const [name, record] of Object.entries(parsed)) {
+			const base = emptyRecord();
+			map.set(name, {
+				...base,
+				...record,
+				state: record.state === "stale" || record.state === "archived" ? record.state : "active"
+			});
+		}
+	} catch {}
+	return map;
+}
+async function saveUsage(root, map, io = nodeEvolutionIo()) {
+	const obj = Object.fromEntries(map.entries());
+	await io.writeText(usageFile(root), JSON.stringify(obj, null, 2));
+}
+function getRecord(map, name) {
+	let record = map.get(name);
+	if (!record) {
+		record = emptyRecord();
+		map.set(name, record);
+	}
+	return record;
+}
+function bumpView(map, name, when = /* @__PURE__ */ new Date()) {
+	const record = getRecord(map, name);
+	record.view_count += 1;
+	record.last_viewed_at = when.toISOString();
+}
+function bumpUse(map, name, when = /* @__PURE__ */ new Date()) {
+	const record = getRecord(map, name);
+	record.use_count += 1;
+	record.last_used_at = when.toISOString();
+}
+function bumpPatch(map, name, when = /* @__PURE__ */ new Date()) {
+	const record = getRecord(map, name);
+	record.patch_count += 1;
+	record.last_patched_at = when.toISOString();
+}
+function markAgentCreated(map, name) {
+	getRecord(map, name).created_by = "agent";
+}
+function latestActivityAt(record) {
+	const values = [
+		record.last_used_at,
+		record.last_viewed_at,
+		record.last_patched_at
+	].filter((value) => typeof value === "string");
+	if (values.length === 0) return null;
+	return values.sort().reverse()[0] ?? null;
+}
+//#endregion
+//#region lib/types/curator.js
+/**
+* Deterministic skill curator: active → stale → archived transitions.
+* Pure function; file moves are performed by SkillLibrary.
+*/
+const PROTECTED_BUILTIN_SKILLS = new Set(["plan"]);
+function buildCuratorRunReport(input) {
+	return {
+		runId: input.runId,
+		startedAt: input.startedAt,
+		finishedAt: input.finishedAt,
+		staleCandidates: [...input.staleCandidates],
+		llmNominations: [...input.llmNominations],
+		archiveCandidates: [...input.archiveCandidates],
+		archived: [...input.archived],
+		failed: [...input.failed],
+		...input.snapshotPath === void 0 ? {} : { snapshotPath: input.snapshotPath }
+	};
+}
+function daysSince(iso, created, now) {
+	return (now - new Date(iso ?? created).getTime()) / 864e5;
+}
+function computeLifecycleTransitions(usage, config, now = /* @__PURE__ */ new Date()) {
+	const result = {
+		transitions: [],
+		archive: [],
+		reactivate: [],
+		markStale: []
+	};
+	for (const [name, record] of usage) {
+		if (record.pinned) continue;
+		if (config.excludeSkillNames?.has(name)) continue;
+		if (record.created_by !== "agent" && config.manageUnmanaged !== true) continue;
+		if (PROTECTED_BUILTIN_SKILLS.has(name)) continue;
+		if (record.state === "archived") continue;
+		const age = daysSince(null, record.created_at, now.getTime());
+		if (record.use_count === 0 && age < config.staleAfterDays) continue;
+		const idle = daysSince(latestActivityAt(record), record.created_at, now.getTime());
+		const qualityWarn = record.quality_warn === true;
+		const staleAfterDays = qualityWarn && config.qualityWarnStaleAfterDays !== void 0 ? config.qualityWarnStaleAfterDays : config.staleAfterDays;
+		if (record.state === "active") {
+			if (idle >= config.archiveAfterDays) {
+				record.state = "archived";
+				record.archived_at = now.toISOString();
+				result.transitions.push({
+					name,
+					from: "active",
+					to: "archived",
+					reason: `idle ${Math.round(idle)}d >= ${config.archiveAfterDays}d`
+				});
+				result.archive.push(name);
+			} else if (idle >= staleAfterDays) {
+				record.state = "stale";
+				const reason = qualityWarn ? `idle ${Math.round(idle)}d >= quality-warn stale ${staleAfterDays}d` : `idle ${Math.round(idle)}d >= ${staleAfterDays}d`;
+				result.transitions.push({
+					name,
+					from: "active",
+					to: "stale",
+					reason
+				});
+				result.markStale.push(name);
+			}
+		} else if (idle < staleAfterDays) {
+			record.state = "active";
+			result.transitions.push({
+				name,
+				from: "stale",
+				to: "active",
+				reason: `recent activity ${Math.round(idle)}d`
+			});
+			result.reactivate.push(name);
+		} else if (idle >= config.archiveAfterDays) {
+			record.state = "archived";
+			record.archived_at = now.toISOString();
+			result.transitions.push({
+				name,
+				from: "stale",
+				to: "archived",
+				reason: `idle ${Math.round(idle)}d >= ${config.archiveAfterDays}d`
+			});
+			result.archive.push(name);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region lib/types/threats.js
+/**
+* Threat scanning for agent-authored memory and skill content.
+*
+* Ported as a small, dependency-free subset of Hermes Agent's
+* `tools/threat_patterns.py` + hermes-claw `threats.ts`. The policy is the
+* load-bearing part: ANY in-scope hit blocks. Severity and category are
+* metadata for diagnostics only.
+*/
+const FILLER = String.raw`(?:\w+\s+){0,8}`;
+const PATTERNS = [
+	{
+		label: "prompt_injection_ignore",
+		category: "prompt_injection",
+		scope: "all",
+		regex: new RegExp(String.raw`ignore\s+${FILLER}(?:previous|above|prior|all)\s+${FILLER}instructions`, "i")
+	},
+	{
+		label: "disregard_rules",
+		category: "prompt_injection",
+		scope: "all",
+		regex: /disregard\s+(?:your|all|any)\s+(?:instructions|rules|guidelines)/i
+	},
+	{
+		label: "system_prompt_override",
+		category: "prompt_injection",
+		scope: "all",
+		regex: /system\s+prompt\s+override/i
+	},
+	{
+		label: "bypass_restrictions",
+		category: "prompt_injection",
+		scope: "all",
+		regex: /act\s+as\s+(?:if|though)\s+(?:you\s+)?(?:have\s+no|don'?t\s+have)\s+(?:restrictions?|limits?|rules)/i
+	},
+	{
+		label: "new_system_prompt",
+		category: "prompt_injection",
+		scope: "strict",
+		regex: new RegExp(String.raw`new\s+${FILLER}system\s+${FILLER}prompt`, "i")
+	},
+	{
+		label: "forget_everything",
+		category: "prompt_injection",
+		scope: "strict",
+		regex: new RegExp(String.raw`forget\s+${FILLER}(?:everything|all)\s+${FILLER}(?:discussed|you\s+know)`, "i")
+	},
+	{
+		label: "role_hijack",
+		category: "role_hijacking",
+		scope: "context",
+		regex: /you\s+are\s+now\s+(?:a|an|the|acting|playing|pretending)/i
+	},
+	{
+		label: "fake_update",
+		category: "role_hijacking",
+		scope: "context",
+		regex: new RegExp(String.raw`you\s+have\s+been\s+${FILLER}(?:updated|upgraded|patched)\s+to`, "i")
+	},
+	{
+		label: "identity_override",
+		category: "role_hijacking",
+		scope: "context",
+		regex: /\bname\s+yourself\s+\w+/i
+	},
+	{
+		label: "remove_filters",
+		category: "role_hijacking",
+		scope: "context",
+		regex: /(?:respond|answer|reply)\s+without\s+(?:restrictions?|limitations?|filters?|safety)/i
+	},
+	{
+		label: "deception_hide",
+		category: "deception",
+		scope: "all",
+		regex: new RegExp(String.raw`do\s+not\s+${FILLER}tell\s+${FILLER}the\s+user`, "i")
+	},
+	{
+		label: "leak_system_prompt",
+		category: "deception",
+		scope: "context",
+		regex: new RegExp(String.raw`output\s+${FILLER}(?:system|initial)\s+prompt`, "i")
+	},
+	{
+		label: "context_exfil",
+		category: "exfiltration",
+		scope: "strict",
+		regex: /(?:include|output|print|share)\s+(?:the\s+)?(?:conversation|chat\s+history|previous\s+messages|(?:full|entire)\s+context)/i
+	},
+	{
+		label: "send_to_url",
+		category: "exfiltration",
+		scope: "strict",
+		regex: /(?:send|post|upload|transmit)\s+[^\n]{0,512}\s+(?:to|at)\s+https?:\/\//i
+	},
+	{
+		label: "exfil_curl",
+		category: "exfiltration",
+		scope: "all",
+		regex: /curl\s+[^\n]{0,512}\$\{?\w*(?:KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|API)/i
+	},
+	{
+		label: "exfil_wget",
+		category: "exfiltration",
+		scope: "all",
+		regex: /wget\s+[^\n]{0,512}\$\{?\w*(?:KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|API)/i
+	},
+	{
+		label: "read_secrets",
+		category: "exfiltration",
+		scope: "all",
+		regex: /cat\s+[^\n]{0,512}(?:\.env|credentials|\.netrc|\.pgpass|\.npmrc|\.pypirc)/i
+	},
+	{
+		label: "ssh_backdoor",
+		category: "persistence",
+		scope: "strict",
+		regex: /authorized_keys/i
+	},
+	{
+		label: "agent_config_mod",
+		category: "persistence",
+		scope: "strict",
+		regex: /(?:update|modify|edit|write|change|append|add\s+to)\s+(?:AGENTS\.md|CLAUDE\.md|\.cursorrules|\.clinerules)/i
+	},
+	{
+		label: "hermes_env",
+		category: "persistence",
+		scope: "strict",
+		regex: /\$?HOME\/\.hermes|~\/\.hermes|\.hermes\/\.env/i
+	},
+	{
+		label: "c2_node_registration",
+		category: "c2_promptware",
+		scope: "context",
+		regex: /register\s+(?:as\s+)?a?\s*node/i
+	},
+	{
+		label: "c2_heartbeat",
+		category: "c2_promptware",
+		scope: "context",
+		regex: /(?:heartbeats?|beacon|check[\s-]?in)\s+(?:to|with)/i
+	},
+	{
+		label: "c2_task_pull",
+		category: "c2_promptware",
+		scope: "context",
+		regex: /pull\s+(?:new\s+)?tasks?/i
+	},
+	{
+		label: "known_c2_framework",
+		category: "c2_promptware",
+		scope: "context",
+		regex: /\b(?:cobalt\s*strike|sliver|havoc|mythic|metasploit|brainworm)\b/i
+	},
+	{
+		label: "hardcoded_secret",
+		category: "hardcoded_secrets",
+		scope: "strict",
+		regex: /(?:api[_-]?key|token|secret|password)\s*[=:]\s*["'][a-z0-9+/=_-]{20,}["']/i
+	},
+	{
+		label: "private_key_block",
+		category: "hardcoded_secrets",
+		scope: "all",
+		regex: /-----BEGIN\s+(?:RSA\s+)?PRIVATE\s+KEY-----/
+	}
+];
+const ZERO_WIDTH_CHARS = /[\u200b\u200c\u200d\u2060\u2062\u2063\u2064\ufeff]/;
+const BIDI_CHARS = /[\u202a-\u202e\u2066-\u2069]/;
+const SCOPE_ORDER = {
+	all: 1,
+	context: 2,
+	strict: 3
+};
+/**
+* Scan text at `scope`. Patterns are cumulative: `strict` includes all scopes.
+*/
+function scanThreats(text, scope = "strict", maxScanChars = 65536) {
+	const findings = [];
+	if (ZERO_WIDTH_CHARS.test(text)) findings.push({
+		label: "unicode_zero_width",
+		category: "unicode_obfuscation",
+		scope
+	});
+	if (BIDI_CHARS.test(text)) findings.push({
+		label: "unicode_bidi_override",
+		category: "unicode_obfuscation",
+		scope
+	});
+	const normalized = text.normalize("NFKC").slice(0, maxScanChars);
+	for (const pattern of PATTERNS) {
+		if (SCOPE_ORDER[pattern.scope] > SCOPE_ORDER[scope]) continue;
+		if (pattern.regex.test(normalized)) findings.push({
+			label: pattern.label,
+			category: pattern.category,
+			scope: pattern.scope
+		});
+	}
+	return findings;
+}
+/** Blocking policy: any hit blocks. `severity` is deliberately not a gate. */
+function evaluateThreat(text, scope = "strict", maxScanChars = 65536) {
+	const findings = scanThreats(text, scope, maxScanChars);
+	return {
+		blocked: findings.length > 0,
+		findings
+	};
+}
+/** User-facing block message for memory writes. */
+function scanMemoryThreats(text, maxScanChars = 65536) {
+	const { blocked, findings } = evaluateThreat(text, "strict", maxScanChars);
+	if (!blocked) return null;
+	const pattern = findings.find((f) => f.category !== "unicode_obfuscation");
+	if (pattern) return `Blocked by security scan (${pattern.label}). Rephrase without instruction-like language.`;
+	return "Blocked by security scan: invisible or potentially malicious Unicode detected.";
+}
+/** User-facing block message for skill content writes. */
+function scanContentThreats(text, maxScanChars = 65536) {
+	const { blocked, findings } = evaluateThreat(text, "strict", maxScanChars);
+	if (!blocked) return null;
+	return `Blocked by security scan (${findings[0]?.label ?? "unknown"}). This content appears to contain potentially malicious instructions.`;
+}
+//#endregion
+//#region lib/types/memory-store.js
+/**
+* File-backed durable memory with Hermes-compatible semantics.
+* Stores are MEMORY.md and USER.md under $DSH_HOME/memories (~/.dsh/memories).
+*/
+const ENTRY_DELIMITER = "\n§\n";
+function memoryRoot(env = process.env) {
+	return join(env.DSH_HOME ?? join(homedir(), ".dsh"), "memories");
+}
+function fileFor(root, target) {
+	return join(root, target === "memory" ? "MEMORY.md" : "USER.md");
+}
+function normalizeEntries(raw) {
+	return raw.split(ENTRY_DELIMITER).map((entry) => entry.trim()).filter(Boolean);
+}
+function render(entries) {
+	return entries.join(ENTRY_DELIMITER) + "\n";
+}
+function stripDatePrefix(entry) {
+	return entry.replace(/^## \d{4}-\d{2}-\d{2}\n/, "");
+}
+var MemoryStore = class {
+	memoryLimit;
+	userLimit;
+	addDatePrefix;
+	root;
+	maxFailures;
+	io;
+	failureCount = 0;
+	constructor(options = {}) {
+		this.io = options.io ?? nodeEvolutionIo();
+		this.memoryLimit = options.memoryCharLimit ?? 2200;
+		this.userLimit = options.userCharLimit ?? 1375;
+		this.addDatePrefix = options.addDatePrefix ?? false;
+		this.root = options.root ?? memoryRoot();
+		this.maxFailures = options.maxConsolidationFailures ?? 3;
+	}
+	limitFor(target) {
+		return target === "memory" ? this.memoryLimit : this.userLimit;
+	}
+	async read(target) {
+		const raw = await this.io.readText(fileFor(this.root, target));
+		return raw === null ? [] : [...new Set(normalizeEntries(raw))];
+	}
+	async write(target, entries) {
+		await this.io.writeText(fileFor(this.root, target), render(entries));
+	}
+	resetFailures() {
+		this.failureCount = 0;
+	}
+	failure(target, message, entries) {
+		this.failureCount += 1;
+		const chars = entries.join(ENTRY_DELIMITER).length;
+		if (this.failureCount > this.maxFailures) return {
+			ok: false,
+			message: `Memory consolidation failed ${this.failureCount} times this turn. Stop retrying memory calls and continue with the user's task.`,
+			entries,
+			chars,
+			limit: this.limitFor(target)
+		};
+		return {
+			ok: false,
+			message,
+			entries,
+			chars,
+			limit: this.limitFor(target)
+		};
+	}
+	async add(target, facts) {
+		const content = facts.trim();
+		if (!content) return {
+			ok: false,
+			message: "Content cannot be empty.",
+			entries: [],
+			chars: 0,
+			limit: this.limitFor(target)
+		};
+		const threat = scanMemoryThreats(content);
+		if (threat) return {
+			ok: false,
+			message: threat,
+			entries: [],
+			chars: 0,
+			limit: this.limitFor(target)
+		};
+		const entries = await this.read(target);
+		if (entries.some((entry) => stripDatePrefix(entry) === content)) {
+			this.resetFailures();
+			return {
+				ok: true,
+				message: "Entry already exists (no duplicate added).",
+				entries,
+				chars: entries.join(ENTRY_DELIMITER).length,
+				limit: this.limitFor(target)
+			};
+		}
+		const next = [...entries, this.addDatePrefix ? `## ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}\n${content}` : content];
+		const total = next.join(ENTRY_DELIMITER).length;
+		if (total > this.limitFor(target)) return this.failure(target, `Adding this entry would exceed the ${this.limitFor(target)} char limit. Consolidate or remove stale entries, then retry.`, entries);
+		await this.write(target, next);
+		this.resetFailures();
+		return {
+			ok: true,
+			message: "Entry added.",
+			entries: next,
+			chars: total,
+			limit: this.limitFor(target)
+		};
+	}
+	async replace(target, oldText, facts) {
+		return this.mutate(target, oldText, "replace", facts);
+	}
+	async remove(target, oldText) {
+		return this.mutate(target, oldText, "remove", void 0);
+	}
+	async mutate(target, oldText, action, facts) {
+		const needle = oldText.trim();
+		if (!needle) return {
+			ok: false,
+			message: "old_text cannot be empty.",
+			entries: [],
+			chars: 0,
+			limit: this.limitFor(target)
+		};
+		const content = action === "replace" ? (facts ?? "").trim() : "";
+		if (action === "replace" && !content) return {
+			ok: false,
+			message: "facts is required for replace; use remove to delete.",
+			entries: [],
+			chars: 0,
+			limit: this.limitFor(target)
+		};
+		if (action === "replace") {
+			const threat = scanMemoryThreats(content);
+			if (threat) return {
+				ok: false,
+				message: threat,
+				entries: [],
+				chars: 0,
+				limit: this.limitFor(target)
+			};
+		}
+		if (await this.detectDrift(target)) return {
+			ok: false,
+			message: "External drift detected in memory file. Resolve the drift before retrying.",
+			entries: [],
+			chars: 0,
+			limit: this.limitFor(target)
+		};
+		const entries = await this.read(target);
+		const matches = entries.map((entry, index) => ({
+			entry,
+			index
+		})).filter(({ entry }) => entry.includes(needle));
+		if (matches.length === 0) return this.failure(target, `No entry matching "${needle}" found.`, entries);
+		if (new Set(matches.map((m) => m.entry)).size > 1) return {
+			ok: false,
+			message: `Multiple distinct entries matched "${needle}". Be more specific.`,
+			entries,
+			chars: entries.join(ENTRY_DELIMITER).length,
+			limit: this.limitFor(target)
+		};
+		const index = matches[0]?.index ?? -1;
+		const next = [...entries];
+		if (action === "remove") next.splice(index, 1);
+		else next[index] = content;
+		const total = next.join(ENTRY_DELIMITER).length;
+		if (total > this.limitFor(target)) return this.failure(target, `Resulting memory would exceed the ${this.limitFor(target)} char limit.`, entries);
+		await this.write(target, next);
+		this.resetFailures();
+		return {
+			ok: true,
+			message: `Entry ${action === "remove" ? "removed" : "replaced"}.`,
+			entries: next,
+			chars: total,
+			limit: this.limitFor(target)
+		};
+	}
+	async applyBatch(target, operations) {
+		if (operations.length === 0) return {
+			ok: false,
+			message: "operations list is empty.",
+			entries: [],
+			chars: 0,
+			limit: this.limitFor(target)
+		};
+		if (await this.detectDrift(target)) return {
+			ok: false,
+			message: "External drift detected in memory file. Resolve the drift before retrying.",
+			entries: [],
+			chars: 0,
+			limit: this.limitFor(target)
+		};
+		const entries = await this.read(target);
+		const working = [...entries];
+		for (const [index, op] of operations.entries()) {
+			const position = index + 1;
+			if (op.action === "add") {
+				const body = (op.facts ?? "").trim();
+				if (!body) return {
+					ok: false,
+					message: `Operation ${position} (add): facts is required. No operations were applied.`,
+					entries,
+					chars: entries.join(ENTRY_DELIMITER).length,
+					limit: this.limitFor(target)
+				};
+				const threat = scanMemoryThreats(body);
+				if (threat) return {
+					ok: false,
+					message: `Operation ${position}: ${threat}`,
+					entries,
+					chars: entries.join(ENTRY_DELIMITER).length,
+					limit: this.limitFor(target)
+				};
+				if (!working.some((entry) => stripDatePrefix(entry) === body)) working.push(this.addDatePrefix ? `## ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}\n${body}` : body);
+				continue;
+			}
+			const needle = (op.old_text ?? "").trim();
+			if (!needle) return {
+				ok: false,
+				message: `Operation ${position} (${op.action}): old_text is required. No operations were applied.`,
+				entries,
+				chars: entries.join(ENTRY_DELIMITER).length,
+				limit: this.limitFor(target)
+			};
+			const matches = working.map((entry, matchIndex) => ({
+				entry,
+				matchIndex
+			})).filter(({ entry }) => entry.includes(needle));
+			if (matches.length === 0) return this.failure(target, `Operation ${position}: no entry matching "${needle}" found. No operations were applied.`, entries);
+			if (new Set(matches.map((m) => m.entry)).size > 1) return {
+				ok: false,
+				message: `Operation ${position}: "${needle}" matched multiple distinct entries. No operations were applied.`,
+				entries,
+				chars: entries.join(ENTRY_DELIMITER).length,
+				limit: this.limitFor(target)
+			};
+			const matchIndex = matches[0]?.matchIndex ?? -1;
+			if (op.action === "remove") working.splice(matchIndex, 1);
+			else {
+				const body = (op.facts ?? "").trim();
+				if (!body) return {
+					ok: false,
+					message: `Operation ${position} (replace): facts is required.`,
+					entries,
+					chars: entries.join(ENTRY_DELIMITER).length,
+					limit: this.limitFor(target)
+				};
+				const threat = scanMemoryThreats(body);
+				if (threat) return {
+					ok: false,
+					message: `Operation ${position}: ${threat}`,
+					entries,
+					chars: entries.join(ENTRY_DELIMITER).length,
+					limit: this.limitFor(target)
+				};
+				working[matchIndex] = body;
+			}
+		}
+		const total = working.join(ENTRY_DELIMITER).length;
+		if (total > this.limitFor(target)) return this.failure(target, `Batch result (${total} chars) exceeds the ${this.limitFor(target)} limit. Remove or shorten more entries in the same batch.`, entries);
+		await this.write(target, working);
+		this.resetFailures();
+		return {
+			ok: true,
+			message: `Applied ${operations.length} operation(s).`,
+			entries: working,
+			chars: total,
+			limit: this.limitFor(target)
+		};
+	}
+	async renderContext() {
+		const memory = await this.read("memory");
+		const user = await this.read("user");
+		const parts = [];
+		for (const [target, entries] of [["Memory", memory], ["User Profile", user]]) {
+			const safe = entries.filter((entry) => !scanMemoryThreats(entry));
+			if (safe.length > 0) {
+				const body = safe.join(ENTRY_DELIMITER);
+				const note = safe.length === entries.length ? "" : ` (${entries.length - safe.length} threat-matched entries filtered)`;
+				parts.push(`## ${target} (${safe.length} entries)${note}\n${body}`);
+			}
+		}
+		return parts.join("\n\n");
+	}
+	async snapshot() {
+		const [memory, user] = await Promise.all([this.read("memory"), this.read("user")]);
+		return {
+			memory,
+			user
+		};
+	}
+	async restoreSnapshot(snapshot) {
+		await this.write("memory", snapshot.memory);
+		await this.write("user", snapshot.user);
+	}
+	async detectDrift(target) {
+		const raw = await this.io.readText(fileFor(this.root, target));
+		if (raw === null) return false;
+		return normalizeEntries(raw).join(ENTRY_DELIMITER) !== raw.trim();
+	}
+};
+//#endregion
+//#region lib/types/prompts.js
+/**
+* Review and curation prompts adapted from Hermes Agent
+* `agent/background_review.py`, `agent/curator.py`, and
+* `agent/learn_prompt.py`, with tool names translated to the DSH-native
+* catalog (`memory`, `skill_manage`, `skill`, `bash`, `str_replace_editor`).
+*
+* Every prompt is pinned in a versioned bundle. Review workers verify the
+* bundle digest before spending a model call, so a partially-patched
+* deployment fails closed instead of silently running a truncated prompt.
+*/
+const PROMPT_BUNDLE_ID = "dsh-evolution@1";
+const MEMORY_REVIEW_PROMPT = `[Auto-review — Memory]
+Review the conversation above and consider saving to memory if appropriate.
+
+Focus on:
+1. Has the user revealed things about themselves — persona, desires, preferences, or personal details worth remembering?
+2. Has the user expressed expectations about how you should behave, their work style, or ways they want you to operate?
+
+If something stands out, save it using the memory tool.
+If nothing is worth saving, just say "Nothing to save." and stop.`;
+const SKILL_REVIEW_PROMPT = `[Auto-review — Skills]
+Review the conversation above and update the skill library. Be ACTIVE — most sessions produce at least one skill update, even if small.
+
+Target shape: CLASS-LEVEL skills with a rich SKILL.md and a references/ directory for session-specific detail. Not a flat list of narrow one-session skills.
+
+Signals that warrant action:
+- The user corrected your style, tone, format, verbosity, workflow, or approach.
+- A non-trivial technique, fix, workaround, or debugging path emerged.
+- A loaded skill turned out wrong, missing, or outdated — patch it now.
+
+Preference order:
+1. Patch a skill that was loaded or read this session.
+2. Patch an existing umbrella skill.
+3. Add references/, templates/, or scripts/ support under an existing skill.
+4. Create a new class-level umbrella skill only when nothing fits.
+
+Protected skills (bundled/hub-installed) must not be edited. Pinned skills may be patched but not archived.
+
+Do NOT capture:
+- Environment-dependent failures (missing binaries, unconfigured credentials).
+- Negative claims about tools ("browser tools do not work").
+- Transient errors that resolved during the session.
+- One-off task narratives.
+
+If a tool failed because of setup state, capture the FIX under an existing setup skill — never "this tool does not work" as a standalone constraint.
+
+"Nothing to save." is a real option but should NOT be the default.`;
+const COMBINED_REVIEW_PROMPT = `[Auto-review]
+Review the conversation above and update two things.
+
+**Memory**: who the user is. Save durable user preferences, personal details, and expectations with the memory tool.
+
+**Skills**: how to do this class of task. Be ACTIVE. Follow the same class-level umbrella policy, preference order, protected-skill rules, and do-not-capture list as a skill review.
+
+Act on whichever dimension has real signal. If genuinely nothing stands out on either, say "Nothing to save." and stop — but don't reach for that conclusion as a default.`;
+const CURATOR_PROMPT = `You are the skill curator. Maintain a healthy, class-level skill library.
+
+Rules:
+1. NEVER hard-delete a skill. Archive is the maximum destructive action.
+2. Do not touch bundled, hub-installed, or pinned skills.
+3. Do not archive recently-created or never-used skills without strong evidence.
+4. Prefer merging narrow skills into class-level umbrellas.
+5. Before archiving a merged skill, ensure its unique content was preserved.
+
+Produce a YAML summary:
+consolidations:
+  - from: <old-skill-name>
+    into: <umbrella-skill-name>
+    reason: <one short sentence>
+prunings:
+  - name: <skill-name>
+    reason: <one short sentence>`;
+function reviewPrompt(kind) {
+	if (kind === "memory") return MEMORY_REVIEW_PROMPT;
+	if (kind === "skill") return SKILL_REVIEW_PROMPT;
+	return COMBINED_REVIEW_PROMPT;
+}
+function sha256(text) {
+	return createHash("sha256").update(text).digest("hex");
+}
+function createPromptBundle(prompts) {
+	const canonical = JSON.stringify({
+		id: PROMPT_BUNDLE_ID,
+		version: 1,
+		prompts: Object.fromEntries(Object.entries(prompts).sort())
+	});
+	return Object.freeze({
+		id: PROMPT_BUNDLE_ID,
+		version: 1,
+		prompts: Object.freeze({ ...prompts }),
+		sha256: sha256(canonical)
+	});
+}
+const PROMPT_BUNDLE = createPromptBundle({
+	memory: MEMORY_REVIEW_PROMPT,
+	skill: SKILL_REVIEW_PROMPT,
+	combined: COMBINED_REVIEW_PROMPT,
+	curator: CURATOR_PROMPT
+});
+function verifyPromptBundle(bundle = PROMPT_BUNDLE) {
+	const canonical = JSON.stringify({
+		id: bundle.id,
+		version: bundle.version,
+		prompts: Object.fromEntries(Object.entries(bundle.prompts).sort())
+	});
+	return bundle.sha256 === sha256(canonical);
+}
+const DSH_AUTHORING_STANDARDS = `Follow the Hermes skill-authoring standards, translated to DSH tools.
+
+Frontmatter:
+- name: lowercase-hyphenated, <=64 chars, no spaces.
+- description: ONE sentence, <=60 characters, ends with a period. State the capability, not the implementation. No marketing words. Do NOT repeat the skill name. Count the characters before saving.
+- version: 0.1.0
+- author: always the literal value "Hermes". NEVER fill it from the environment, git config, or any identity you can probe.
+- platforms: declare [macos], [linux], and/or [windows] only when the skill is genuinely OS-bound; omit for portable skills.
+- metadata.hermes.tags: a few Capitalized, Relevant, Tags.
+
+Body section order (omit only when empty):
+1. "# <Human Title>" then a 2-3 sentence intro: what it does, what it does NOT do, key dependency stance.
+2. "## When to Use" — concrete trigger phrases.
+3. "## Prerequisites" — exact env vars, install steps, credentials.
+4. "## How to Run" — canonical invocation framed through DSH tools.
+5. "## Quick Reference" — flat command/endpoint list.
+6. "## Procedure" — numbered steps with copy-paste-exact commands.
+7. "## Pitfalls" — known limits and rate limits.
+8. "## Verification" — one check proving the skill worked.
+
+DSH-tool framing:
+- Reference DSH tools by name in backticks: \`bash\`, \`str_replace_editor\`, \`write\`, \`skill\`, \`skill_manage\`, \`memory\`.
+- Do not name wrapped shell utilities when a DSH tool already covers them.
+- Larger scripts belong under \`scripts/\` (written with \`skill_manage write_file\`) and are referenced from SKILL.md by relative path.
+
+Quality bar:
+- Prefer verbatim flags, paths, and APIs from the source. Never invent them.
+- Keep it tight: ~100 lines simple, ~200 complex.
+- No router/index/hub skills that only point at other skills.
+- References go in \`references/\`, templates in \`templates/\`.`;
+//#endregion
+//#region lib/types/signals.js
+/**
+* Deterministic review signal gate.
+*
+* Scans a DSH session event log for durable learning signals before any LLM
+* is spent. `turn/end` calls `observeTurn`; the returned review kind is
+* accumulated until a configured interval fires.
+*/
+const CORRECTION_PATTERNS = [
+	/(?:don'?t|do not|stop|never)\s+(?:do|use|format|explain|write|say)/i,
+	/(?:too|very|way\s+too)\s+(?:verbose|long|detailed|short|brief)/i,
+	/(?:I|we)\s+(?:prefer|like|want|need)\b/i,
+	/remember\s+(?:this|that|to)/i
+];
+const FIX_PATTERNS = [/worked after|fixed by|the fix was|root cause/i, /retry(?:ing)? worked|workaround/i];
+/** Fold one session event into the current turn observation. */
+function observeEvent(signal, event) {
+	if (event.type === "user/message") {
+		const text = event.data.content.map((block) => block.type === "text" ? block.text : "").join(" ");
+		signal.userChars += text.length;
+		if (CORRECTION_PATTERNS.some((pattern) => pattern.test(text))) signal.memorySignal = true;
+		if (FIX_PATTERNS.some((pattern) => pattern.test(text))) signal.skillSignal = true;
+		return;
+	}
+	if (event.type === "assistant/message") {
+		const text = event.data.message.content.map((block) => block.type === "text" ? block.text : "").join(" ");
+		signal.assistantChars += text.length;
+		return;
+	}
+	if (event.type === "tool/call") {
+		signal.toolCalls += 1;
+		if (event.data.name === "skill") signal.skillSignal = true;
+		if (event.data.name === "skill_manage") signal.skillSignal = true;
+	}
+}
+/** Compute review cadence after `turn/end`. */
+function advanceReview(state, turn, signal, config) {
+	if (turn === state.lastTurn) return null;
+	state.lastTurn = turn;
+	signal.substantive = signal.toolCalls >= config.substantiveMinToolCalls || signal.userChars >= config.substantiveMinUserChars || signal.assistantChars >= config.substantiveMinAgentChars;
+	if (!signal.substantive) return null;
+	state.turnsSinceMemory += signal.memorySignal ? 1 : 0;
+	state.turnsSinceSkill += signal.skillSignal ? 1 : Math.max(1, signal.toolCalls);
+	const memoryDue = state.turnsSinceMemory >= config.memoryInterval;
+	const skillDue = state.turnsSinceSkill >= config.skillInterval;
+	if (memoryDue && skillDue) {
+		state.turnsSinceMemory = 0;
+		state.turnsSinceSkill = 0;
+		return "combined";
+	}
+	if (memoryDue) {
+		state.turnsSinceMemory = 0;
+		return "memory";
+	}
+	if (skillDue) {
+		state.turnsSinceSkill = 0;
+		return "skill";
+	}
+	return null;
+}
+/** Fold all events between two sequence boundaries into one TurnSignals. */
+function foldTurn(session, fromSeq) {
+	const signal = {
+		substantive: false,
+		toolCalls: 0,
+		userChars: 0,
+		assistantChars: 0,
+		memorySignal: false,
+		skillSignal: false
+	};
+	for (let index = Math.max(0, fromSeq); index < session.events.length; index += 1) {
+		const event = session.events[index];
+		if (event) observeEvent(signal, event);
+	}
+	return signal;
+}
+//#endregion
+//#region lib/types/skill-store.js
+/**
+* Skill library management for the self-evolution plugin.
+*
+* Skills live under `$DSH_HOME/skills` (`~/.dsh/skills` by default), matching
+* the default dsh skill-filesystem user root. The plugin only manages skills
+* it created unless a `.hermes-managed` marker opts a skill in. Archival is a
+* move to `.archive/` — never a hard delete.
+*/
+const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+const MAX_SKILL_NAME_LENGTH = 64;
+const MAX_DESCRIPTION_LENGTH = 1024;
+const MAX_SKILL_CONTENT_CHARS = 1e5;
+const MAX_SKILL_FILE_BYTES = 1048576;
+const DEFAULT_SKILL_LIMITS = {
+	maxNameLength: 64,
+	maxDescriptionLength: MAX_DESCRIPTION_LENGTH,
+	maxSkillContentChars: MAX_SKILL_CONTENT_CHARS,
+	maxSkillFileBytes: MAX_SKILL_FILE_BYTES
+};
+const SUPPORT_DIRS = [
+	"references",
+	"templates",
+	"scripts",
+	"assets"
+];
+function skillsRoot(env = process.env) {
+	return join(env.DSH_HOME ?? join(homedir(), ".dsh"), "skills");
+}
+function skillDir(root, name) {
+	return join(root, name);
+}
+function markerPath(dir, marker) {
+	return join(dir, `.${marker}`);
+}
+function parseFrontmatter(content) {
+	if (!content.trimStart().startsWith("---")) return null;
+	const end = content.indexOf("\n---", 3);
+	if (end < 0) return null;
+	const block = content.slice(3, end);
+	const body = content.slice(end + 4).trim();
+	if (!body) return null;
+	const frontmatter = {};
+	for (const line of block.split("\n")) {
+		const match = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+		if (match) {
+			const [, key, value] = match;
+			if (key && value !== void 0) frontmatter[key] = value.trim().replace(/^["']|["']$/g, "");
+		}
+	}
+	return {
+		frontmatter,
+		body
+	};
+}
+function validateFrontmatter(content, expectedName, limits = DEFAULT_SKILL_LIMITS) {
+	const parsed = parseFrontmatter(content);
+	if (!parsed) return "SKILL.md must start and end with YAML frontmatter and include a body.";
+	if (!parsed.frontmatter.name) return "Frontmatter must include a name field.";
+	if (!/^[a-z0-9][a-z0-9-]*$/.test(parsed.frontmatter.name)) return `Invalid skill name "${parsed.frontmatter.name}" — use lowercase letters, digits, and hyphens.`;
+	if (parsed.frontmatter.name.length > limits.maxNameLength) return `Skill name exceeds ${limits.maxNameLength} characters.`;
+	if (expectedName && parsed.frontmatter.name !== expectedName) return `Frontmatter name "${parsed.frontmatter.name}" does not match target skill "${expectedName}".`;
+	if (!parsed.frontmatter.description) return "Frontmatter must include a description field.";
+	if (parsed.frontmatter.description.length > limits.maxDescriptionLength) return `Description exceeds ${limits.maxDescriptionLength} characters.`;
+	if (content.length > limits.maxSkillContentChars) return `SKILL.md content exceeds ${limits.maxSkillContentChars} characters.`;
+	return null;
+}
+async function listNames(root, io) {
+	const entries = await io.list(root);
+	const names = [];
+	for (const entry of entries) {
+		if (entry.startsWith(".")) continue;
+		if (await io.exists(join(root, entry, "SKILL.md"))) names.push(entry);
+	}
+	return names.sort();
+}
+function validateSupportPath(filePath) {
+	const normalized = filePath.replace(/\\/g, "/");
+	if (normalized.includes("..")) return "Path traversal is not allowed.";
+	const parts = normalized.split("/").filter(Boolean);
+	if (parts.length === 0 || !SUPPORT_DIRS.includes(parts[0])) return `file_path must be under one of: ${SUPPORT_DIRS.join(", ")}.`;
+	if (parts.length < 2) return "Provide a file name, not just a directory.";
+	return null;
+}
+function fuzzyPatch(content, oldString, newString, replaceAll = false) {
+	if (content.includes(oldString)) return replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
+	const trimmed = content.replaceAll(/[ 	]+$/gm, "");
+	if (trimmed.includes(oldString)) return trimmed.replace(oldString, newString);
+	const whitespace = content.replaceAll(/[ 	]+/g, " ");
+	if (whitespace.includes(oldString)) return whitespace.replace(oldString, newString);
+	return null;
+}
+var SkillLibrary = class {
+	root;
+	limits;
+	io;
+	constructor(root = skillsRoot(), io = nodeEvolutionIo(), limits = DEFAULT_SKILL_LIMITS) {
+		this.root = root;
+		this.io = io;
+		this.limits = limits;
+	}
+	async list() {
+		const summaries = [];
+		for (const name of await listNames(this.root, this.io)) {
+			const dir = skillDir(this.root, name);
+			const md = await this.io.readText(join(dir, "SKILL.md"));
+			if (!md) continue;
+			const parsed = parseFrontmatter(md);
+			const protectedBy = await this.deleteProtection(name);
+			const managed = await this.io.exists(markerPath(dir, "hermes-managed"));
+			summaries.push({
+				name,
+				description: parsed?.frontmatter.description ?? "",
+				path: dir,
+				protectedBy,
+				managed,
+				archived: false
+			});
+		}
+		return summaries;
+	}
+	async read(name) {
+		return this.io.readText(join(skillDir(this.root, name), "SKILL.md"));
+	}
+	async writeProtection(name) {
+		const dir = skillDir(this.root, name);
+		for (const marker of ["bundled", "hub-installed"]) if (await this.io.exists(markerPath(dir, marker))) return marker;
+		return null;
+	}
+	async deleteProtection(name) {
+		const dir = skillDir(this.root, name);
+		for (const marker of [
+			"bundled",
+			"hub-installed",
+			"pinned"
+		]) if (await this.io.exists(markerPath(dir, marker))) return marker;
+		return null;
+	}
+	async isManaged(name) {
+		const dir = skillDir(this.root, name);
+		return await this.io.exists(markerPath(dir, "hermes-managed"));
+	}
+	async create(name, content, origin) {
+		const normalized = name.trim();
+		if (!SKILL_NAME_RE.test(normalized) || normalized.length > this.limits.maxNameLength) return {
+			ok: false,
+			message: `Invalid skill name "${normalized}". Use lowercase letters, digits, and hyphens (<= ${this.limits.maxNameLength}).`
+		};
+		const validation = validateFrontmatter(content, normalized, this.limits);
+		if (validation) return {
+			ok: false,
+			message: validation
+		};
+		const threat = scanContentThreats(content);
+		if (threat) return {
+			ok: false,
+			message: threat
+		};
+		const dir = skillDir(this.root, normalized);
+		if (await this.io.exists(join(dir, "SKILL.md"))) return {
+			ok: false,
+			message: `Skill "${normalized}" already exists.`
+		};
+		await this.io.writeText(join(dir, "SKILL.md"), content.trimEnd() + "\n");
+		if (origin === "background_review") await this.io.writeText(markerPath(dir, "hermes-managed"), "");
+		return {
+			ok: true,
+			message: `Skill "${normalized}" created.`,
+			path: dir
+		};
+	}
+	async update(name, content) {
+		const dir = skillDir(this.root, name);
+		if (!await this.io.readText(join(dir, "SKILL.md"))) return {
+			ok: false,
+			message: `Skill "${name}" not found.`
+		};
+		const protection = await this.writeProtection(name);
+		if (protection) return {
+			ok: false,
+			message: `Skill "${name}" is protected (${protection}).`
+		};
+		const validation = validateFrontmatter(content, name, this.limits);
+		if (validation) return {
+			ok: false,
+			message: validation
+		};
+		const threat = scanContentThreats(content);
+		if (threat) return {
+			ok: false,
+			message: threat
+		};
+		await this.io.writeText(join(dir, "SKILL.md"), content.trimEnd() + "\n");
+		return {
+			ok: true,
+			message: `Skill "${name}" updated.`,
+			path: dir
+		};
+	}
+	async patch(name, oldString, newString, filePath = "", replaceAll = false) {
+		const dir = skillDir(this.root, name);
+		const skillMd = join(dir, "SKILL.md");
+		if (!await this.io.exists(skillMd)) return {
+			ok: false,
+			message: `Skill "${name}" not found.`
+		};
+		const protection = await this.writeProtection(name);
+		if (protection) return {
+			ok: false,
+			message: `Skill "${name}" is protected (${protection}).`
+		};
+		let target = skillMd;
+		let patchLabel = "SKILL.md";
+		if (filePath) {
+			const validation = validateSupportPath(filePath);
+			if (validation) return {
+				ok: false,
+				message: validation
+			};
+			target = join(dir, ...filePath.replace(/\\/g, "/").split("/").filter(Boolean));
+			patchLabel = filePath;
+		}
+		const md = await this.io.readText(target);
+		if (!md) return {
+			ok: false,
+			message: `File not found: ${patchLabel}`
+		};
+		const patched = fuzzyPatch(md, oldString, newString, replaceAll);
+		if (!patched) return {
+			ok: false,
+			message: `Could not find old_string in "${name}/${patchLabel}". Use update for a full rewrite.`
+		};
+		if (target === skillMd) {
+			const validation = validateFrontmatter(patched, name, this.limits);
+			if (validation) return {
+				ok: false,
+				message: `Patch rejected: ${validation}`
+			};
+		}
+		if (Buffer.byteLength(patched, "utf8") > this.limits.maxSkillFileBytes && target !== skillMd) return {
+			ok: false,
+			message: `Patched file exceeds ${this.limits.maxSkillFileBytes} bytes.`
+		};
+		if (patched.length > this.limits.maxSkillContentChars && target === skillMd) return {
+			ok: false,
+			message: `Patched content exceeds ${this.limits.maxSkillContentChars} characters.`
+		};
+		const threat = scanContentThreats(patched);
+		if (threat) return {
+			ok: false,
+			message: threat
+		};
+		await this.io.writeText(target, patched.trimEnd() + "\n");
+		return {
+			ok: true,
+			message: `Skill "${name}" patched (${patchLabel}).`,
+			path: dir
+		};
+	}
+	async archive(name, absorbedInto = "") {
+		const dir = skillDir(this.root, name);
+		if (!await this.io.readText(join(dir, "SKILL.md"))) return {
+			ok: false,
+			message: `Skill "${name}" not found.`
+		};
+		const protection = await this.deleteProtection(name);
+		if (protection) return {
+			ok: false,
+			message: `Skill "${name}" is protected (${protection}).`
+		};
+		if (absorbedInto) {
+			if (!await this.io.readText(join(skillDir(this.root, absorbedInto), "SKILL.md"))) return {
+				ok: false,
+				message: `absorbed_into="${absorbedInto}" does not exist.`
+			};
+		}
+		const archiveRoot = join(this.root, ".archive");
+		let dest = join(archiveRoot, name);
+		if (await this.io.exists(dest)) dest = join(archiveRoot, `${name}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14)}`);
+		try {
+			await this.io.rename(dir, dest);
+		} catch {
+			await this.io.copy(dir, dest);
+			await this.io.remove(dir);
+		}
+		const reason = absorbedInto ? `Consolidated into ${absorbedInto}` : "Archived by self-evolution curator";
+		await this.io.writeText(join(dest, ".archive-reason"), `${(/* @__PURE__ */ new Date()).toISOString()}: ${reason}\n`);
+		return {
+			ok: true,
+			message: `Skill "${name}" archived to .archive.`,
+			path: dest
+		};
+	}
+	async writeSupportFile(name, filePath, content) {
+		const dir = skillDir(this.root, name);
+		if (!await this.io.exists(join(dir, "SKILL.md"))) return {
+			ok: false,
+			message: `Skill "${name}" not found.`
+		};
+		const protection = await this.writeProtection(name);
+		if (protection) return {
+			ok: false,
+			message: `Skill "${name}" is protected (${protection}).`
+		};
+		const validation = validateSupportPath(filePath);
+		if (validation) return {
+			ok: false,
+			message: validation
+		};
+		if (Buffer.byteLength(content, "utf8") > this.limits.maxSkillFileBytes) return {
+			ok: false,
+			message: `Support file exceeds ${this.limits.maxSkillFileBytes} bytes.`
+		};
+		const threat = scanContentThreats(content);
+		if (threat) return {
+			ok: false,
+			message: threat
+		};
+		const target = join(dir, ...filePath.replace(/\\/g, "/").split("/").filter(Boolean));
+		await this.io.writeText(target, content);
+		return {
+			ok: true,
+			message: `Support file "${filePath}" written to "${name}".`,
+			path: target
+		};
+	}
+	async removeSupportFile(name, filePath) {
+		const dir = skillDir(this.root, name);
+		if (!await this.io.exists(join(dir, "SKILL.md"))) return {
+			ok: false,
+			message: `Skill "${name}" not found.`
+		};
+		const protection = await this.writeProtection(name);
+		if (protection) return {
+			ok: false,
+			message: `Skill "${name}" is protected (${protection}).`
+		};
+		const validation = validateSupportPath(filePath);
+		if (validation) return {
+			ok: false,
+			message: validation
+		};
+		const target = join(dir, ...filePath.replace(/\\/g, "/").split("/").filter(Boolean));
+		if (!await this.io.exists(target)) return {
+			ok: false,
+			message: `File "${filePath}" not found in skill "${name}".`
+		};
+		await this.io.remove(target);
+		return {
+			ok: true,
+			message: `Support file "${filePath}" removed from "${name}".`,
+			path: target
+		};
+	}
+	async snapshotAll(reason = "pre-mutation") {
+		const dest = join(join(this.root, ".backups"), `skills-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`);
+		const names = await listNames(this.root, this.io);
+		for (const name of names) await this.io.copy(skillDir(this.root, name), join(dest, name));
+		await this.io.writeText(join(dest, "manifest.json"), JSON.stringify({
+			reason,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			skills: names
+		}, null, 2));
+		return dest;
+	}
+	async listSnapshots() {
+		const backupRoot = join(this.root, ".backups");
+		let entries;
+		try {
+			entries = await this.io.list(backupRoot);
+		} catch {
+			return [];
+		}
+		const out = [];
+		for (const name of entries.sort().reverse()) {
+			if (!name.startsWith("skills-")) continue;
+			try {
+				const raw = await this.io.readText(join(backupRoot, name, "manifest.json"));
+				if (raw === null) continue;
+				const manifest = JSON.parse(raw);
+				out.push({
+					path: join(backupRoot, name),
+					createdAt: manifest.createdAt ?? "",
+					reason: manifest.reason ?? ""
+				});
+			} catch {}
+		}
+		return out;
+	}
+	async restoreLatestSnapshot() {
+		const latest = (await this.listSnapshots())[0];
+		if (!latest) return {
+			ok: false,
+			message: "No skill snapshot available."
+		};
+		await this.snapshotAll("pre-rollback");
+		for (const name of await listNames(this.root, this.io)) await this.io.remove(skillDir(this.root, name));
+		const entries = await this.io.list(latest.path);
+		for (const entry of entries) {
+			if (entry === "manifest.json") continue;
+			await this.io.copy(join(latest.path, entry), join(this.root, entry));
+		}
+		return {
+			ok: true,
+			message: `Restored skill tree from ${latest.path}`,
+			path: latest.path
+		};
+	}
+};
+//#endregion
+//#region lib/types/state-store.js
+/**
+* Small crash-safe JSON state store for plugin-owned sidecar state.
+* Writes are atomic (temp + rename). Reads are synchronous for startup use.
+*/
+function evolutionHome(env = process.env) {
+	return join(env.DSH_HOME ?? join(homedir(), ".dsh"), "evolution");
+}
+var JsonState = class {
+	initial;
+	path;
+	value;
+	constructor(name, initial, env = process.env) {
+		this.initial = initial;
+		this.path = join(evolutionHome(env), name);
+		this.value = this.loadSync();
+	}
+	loadSync() {
+		try {
+			const raw = readFileSync(this.path, "utf8");
+			const parsed = JSON.parse(raw);
+			return {
+				...this.initial,
+				...parsed
+			};
+		} catch {
+			return { ...this.initial };
+		}
+	}
+	get() {
+		return this.value;
+	}
+	set(value) {
+		this.value = value;
+	}
+	update(mutator) {
+		mutator(this.value);
+	}
+	async flush() {
+		await mkdir(dirname(this.path), { recursive: true });
+		const tmp = `${this.path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+		await writeFile(tmp, JSON.stringify(this.value, null, 2), "utf8");
+		await rename(tmp, this.path);
+	}
+	/** Merge-on-load helper for persisted maps/records. */
+	async reload() {
+		try {
+			const raw = await readFile(this.path, "utf8");
+			this.value = {
+				...this.initial,
+				...JSON.parse(raw)
+			};
+		} catch {
+			this.value = { ...this.initial };
+		}
+	}
+};
+//#endregion
+export { COMBINED_REVIEW_PROMPT, CURATOR_PROMPT, DEFAULT_SKILL_LIMITS, DSH_AUTHORING_STANDARDS, ENTRY_DELIMITER, JsonState, MAX_DESCRIPTION_LENGTH, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MEMORY_REVIEW_PROMPT, MemoryStore, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROTECTED_BUILTIN_SKILLS, SKILL_NAME_RE, SKILL_REVIEW_PROMPT, SUPPORT_DIRS, SkillLibrary, advanceReview, buildCuratorRunReport, bumpPatch, bumpUse, bumpView, childPath, computeLifecycleTransitions, emptyRecord, evaluateThreat, evolutionHome, evolutionIoAdapter, foldTurn, getRecord, latestActivityAt, loadUsage, markAgentCreated, memoryRoot, nodeEvolutionIo, observeEvent, parseFrontmatter, reviewPrompt, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, skillsRoot, usageFile, validateFrontmatter, verifyPromptBundle };