@lmzhen/dsh-evolution-core 0.1.0-rc.2 → 0.1.0-rc.20

package/lib/index.js

@@ -1,4 +1,4 @@
-import { dirname, join } from "node:path";
+import { basename, 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";
@@ -72,10 +72,6 @@ function nodeEvolutionIo() {
 		}
 	};
 }
-/** Absolute path helper kept separate so stores stay platform-correct. */
-function childPath(parent, ...parts) {
-	return join(parent, ...parts);
-}
 //#endregion
 //#region lib/types/usage.js
 /**
@@ -155,15 +151,99 @@ function latestActivityAt(record) {
 	if (values.length === 0) return null;
 	return values.sort().reverse()[0] ?? null;
 }
+/**
+* Curator suppression sidecar: built-in skills the curator has archived stay
+* suppressed across re-seeds, so the lifecycle never fights a re-created
+* bundled skill. Best-effort load/save, mirroring the usage sidecar posture.
+* Versioned shape ({ version, names }) with legacy plain-array compat.
+*/
+const SUPPRESSED_FILE_VERSION = 1;
+function suppressedFile(root) {
+	return join(root, ".curator-suppressed.json");
+}
+async function loadSuppressedNames(root, io = nodeEvolutionIo()) {
+	const raw = await io.readText(suppressedFile(root));
+	if (raw === null) return /* @__PURE__ */ new Set();
+	try {
+		const parsed = JSON.parse(raw);
+		const names = Array.isArray(parsed) ? parsed : typeof parsed === "object" && parsed !== null && Array.isArray(parsed.names) ? parsed.names : [];
+		return new Set(names.filter((entry) => typeof entry === "string"));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+async function saveSuppressedNames(root, names, io = nodeEvolutionIo()) {
+	await io.writeText(suppressedFile(root), JSON.stringify({
+		version: 1,
+		names: [...names].sort()
+	}, null, 2));
+}
+//#endregion
+//#region lib/types/constants.js
+/**
+* Shared constants for the dsh-evolution plugin family.
+*
+* Two classes of value live here, deliberately separated by section so future
+* edits do not blur the semantic boundary:
+*
+* 1. **Fixed protocol/format/security invariants** — changing these breaks an
+*    on-disk format, a naming/format contract, a path-security boundary, or a
+*    cross-component invariant. They are NOT exposed as deployment config.
+*
+* 2. **Cross-package shared tunable defaults** — the same semantic default is
+*    read (with a config override path) by more than one package (e.g.
+*    `evolution-policy` and `evolution-curator` both default `staleAfterDays`
+*    to 30). Centralizing them here means one authoritative default: a config
+*    override still applies per package, but the fallback is single-sourced.
+*
+* Package-private tunables (used by exactly one package) stay in that package,
+* not here — see evolution-replay's `DEFAULT_WEIGHTS` and evolution-feedback's
+* threshold, which are intentionally left where they are used.
+* @module @lmzhen/dsh-evolution-core
+*/
+/** Skill frontmatter `name` validated for the file name (lowercase + hyphen). */
+const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+/** Allowed skill support-file subdirectories (path-traversal boundary). */
+const SUPPORT_DIRS = [
+	"references",
+	"templates",
+	"scripts",
+	"assets"
+];
+/** Delimiter between durable memory entries (on-disk storage format). */
+const ENTRY_DELIMITER = "\n§\n";
+/** Built-in skill names the curator must never lifecycle-manage. */
+const PROTECTED_BUILTIN_SKILLS = new Set(["plan"]);
+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_REVIEW_MEMORY_INTERVAL = 10;
+const DEFAULT_REVIEW_SKILL_INTERVAL = 10;
+/** Skill-review completion channel trigger mode: 'cadence' | 'completion' | 'both'. */
+const DEFAULT_SKILL_REVIEW_TRIGGER = "both";
+/** Cumulative session tool calls before a session counts as "proven long" for the completion channel. */
+const DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS = 20;
+const DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS = 3;
+const DEFAULT_SUBSTANTIVE_MIN_USER_CHARS = 200;
+const DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS = 500;
+const DEFAULT_MAX_OPS_PER_PLAN = 32;
+const DEFAULT_CURATOR_INTERVAL_HOURS = 168;
+const DEFAULT_MIN_IDLE_HOURS = 2;
+const DEFAULT_STALE_AFTER_DAYS = 30;
+const DEFAULT_ARCHIVE_AFTER_DAYS = 90;
+const DEFAULT_MEMORY_CHAR_LIMIT = 2200;
+const DEFAULT_USER_CHAR_LIMIT = 1375;
+const DEFAULT_SKILL_CONTENT_CHARS = 1e5;
 //#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 {
+		schemaVersion: 1,
 		runId: input.runId,
 		startedAt: input.startedAt,
 		finishedAt: input.finishedAt,
@@ -175,6 +255,47 @@ function buildCuratorRunReport(input) {
 		...input.snapshotPath === void 0 ? {} : { snapshotPath: input.snapshotPath }
 	};
 }
+const NOMINATION_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+/**
+* Parse the curator LLM's YAML nomination block (consolidations + prunings).
+* Line-oriented and lenient by design: the LLM output is advisory, every name
+* is re-validated against the tree before any file move happens downstream.
+*/
+function parseCuratorNominations(text) {
+	const prunings = [];
+	const consolidations = [];
+	let section = null;
+	let currentFrom = "";
+	for (const line of text.split("\n")) {
+		const consolidated = /^\s*-\s*from:\s*([a-z0-9][a-z0-9-]*)\s*$/.exec(line);
+		if (consolidated) {
+			section = "consolidations";
+			currentFrom = consolidated[1] ?? "";
+			continue;
+		}
+		const into = /^\s*into:\s*([a-z0-9][a-z0-9-]*)\s*$/.exec(line);
+		if (into) {
+			const intoName = into[1] ?? "";
+			if (section === "consolidations" && currentFrom !== "" && currentFrom !== intoName) consolidations.push({
+				from: currentFrom,
+				into: intoName
+			});
+			currentFrom = "";
+			continue;
+		}
+		const pruned = /^\s*-\s*name:\s*([a-z0-9][a-z0-9-]*)\s*$/.exec(line);
+		if (pruned) {
+			section = "prunings";
+			const name = pruned[1];
+			if (name) prunings.push(name);
+		}
+	}
+	const valid = (name) => NOMINATION_NAME_RE.test(name);
+	return {
+		prunings: prunings.filter(valid),
+		consolidations: consolidations.filter((item) => valid(item.from) && valid(item.into))
+	};
+}
 function daysSince(iso, created, now) {
 	return (now - new Date(iso ?? created).getTime()) / 864e5;
 }
@@ -188,7 +309,10 @@ function computeLifecycleTransitions(usage, config, now = /* @__PURE__ */ new Da
 	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 (config.suppressedNames?.has(name)) continue;
+		if (config.referencedSkillNames?.has(name)) continue;
+		const bundled = config.bundledNames?.has(name) === true;
+		if (!(record.created_by === "agent" || config.manageUnmanaged === true) && !(config.pruneBuiltins === true && bundled)) continue;
 		if (PROTECTED_BUILTIN_SKILLS.has(name)) continue;
 		if (record.state === "archived") continue;
 		const age = daysSince(null, record.created_at, now.getTime());
@@ -417,10 +541,12 @@ const SCOPE_ORDER = {
 	context: 2,
 	strict: 3
 };
+const NO_SCAN_OPTIONS = {};
 /**
 * Scan text at `scope`. Patterns are cumulative: `strict` includes all scopes.
+* `options.excludeLabels` removes matching patterns without changing `scope`.
 */
-function scanThreats(text, scope = "strict", maxScanChars = 65536) {
+function scanThreats(text, scope = "strict", maxScanChars = 65536, options = NO_SCAN_OPTIONS) {
 	const findings = [];
 	if (ZERO_WIDTH_CHARS.test(text)) findings.push({
 		label: "unicode_zero_width",
@@ -433,8 +559,10 @@ function scanThreats(text, scope = "strict", maxScanChars = 65536) {
 		scope
 	});
 	const normalized = text.normalize("NFKC").slice(0, maxScanChars);
+	const excluded = new Set(options.excludeLabels ?? []);
 	for (const pattern of PATTERNS) {
 		if (SCOPE_ORDER[pattern.scope] > SCOPE_ORDER[scope]) continue;
+		if (excluded.has(pattern.label)) continue;
 		if (pattern.regex.test(normalized)) findings.push({
 			label: pattern.label,
 			category: pattern.category,
@@ -444,24 +572,24 @@ function scanThreats(text, scope = "strict", maxScanChars = 65536) {
 	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);
+function evaluateThreat(text, scope = "strict", maxScanChars = 65536, options = NO_SCAN_OPTIONS) {
+	const findings = scanThreats(text, scope, maxScanChars, options);
 	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);
+function scanMemoryThreats(text, maxScanChars = 65536, options = NO_SCAN_OPTIONS) {
+	const { blocked, findings } = evaluateThreat(text, "strict", maxScanChars, options);
 	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);
+function scanContentThreats(text, maxScanChars = 65536, options = NO_SCAN_OPTIONS) {
+	const { blocked, findings } = evaluateThreat(text, "strict", maxScanChars, options);
 	if (!blocked) return null;
 	return `Blocked by security scan (${findings[0]?.label ?? "unknown"}). This content appears to contain potentially malicious instructions.`;
 }
@@ -471,7 +599,6 @@ function scanContentThreats(text, maxScanChars = 65536) {
 * 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");
 }
@@ -534,6 +661,30 @@ var MemoryStore = class {
 			limit: this.limitFor(target)
 		};
 	}
+	/** Percent-based storage hint appended to success message once the target is ≥80% full. */
+	storageHint(target, chars) {
+		const limit = this.limitFor(target);
+		if (limit <= 0) return "";
+		const percent = Math.floor(chars * 100 / limit);
+		return percent >= 80 ? ` ⚠️ Storage at ${percent}% (${chars}/${limit} chars).` : "";
+	}
+	/**
+	* Best-effort copy of the drifted on-disk file to `<file>.bak.<stamp>` before
+	* refusing the write, so an external edit stays recoverable. Failure to back
+	* up does not change the refusal semantics.
+	*/
+	async backupDrift(target) {
+		const path = fileFor(this.root, target);
+		const raw = await this.io.readText(path);
+		if (raw === null) return null;
+		const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14);
+		try {
+			await this.io.writeText(`${path}.bak.${stamp}`, raw);
+			return `${path}.bak.${stamp}`;
+		} catch {
+			return null;
+		}
+	}
 	async add(target, facts) {
 		const content = facts.trim();
 		if (!content) return {
@@ -556,7 +707,7 @@ var MemoryStore = class {
 			this.resetFailures();
 			return {
 				ok: true,
-				message: "Entry already exists (no duplicate added).",
+				message: `Entry already exists (no duplicate added).${this.storageHint(target, entries.join(ENTRY_DELIMITER).length)}`,
 				entries,
 				chars: entries.join(ENTRY_DELIMITER).length,
 				limit: this.limitFor(target)
@@ -569,7 +720,7 @@ var MemoryStore = class {
 		this.resetFailures();
 		return {
 			ok: true,
-			message: "Entry added.",
+			message: `Entry added.${this.storageHint(target, total)}`,
 			entries: next,
 			chars: total,
 			limit: this.limitFor(target)
@@ -608,13 +759,16 @@ var MemoryStore = class {
 				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)
-		};
+		if (await this.detectDrift(target)) {
+			const backup = await this.backupDrift(target);
+			return {
+				ok: false,
+				message: `External drift detected in memory file.${backup ? ` A backup was saved to ${basename(backup)}.` : ""} 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,
@@ -638,7 +792,7 @@ var MemoryStore = class {
 		this.resetFailures();
 		return {
 			ok: true,
-			message: `Entry ${action === "remove" ? "removed" : "replaced"}.`,
+			message: `Entry ${action === "remove" ? "removed" : "replaced"}.${this.storageHint(target, total)}`,
 			entries: next,
 			chars: total,
 			limit: this.limitFor(target)
@@ -652,13 +806,16 @@ var MemoryStore = class {
 			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)
-		};
+		if (await this.detectDrift(target)) {
+			const backup = await this.backupDrift(target);
+			return {
+				ok: false,
+				message: `External drift detected in memory file.${backup ? ` A backup was saved to ${basename(backup)}.` : ""} 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()) {
@@ -731,7 +888,7 @@ var MemoryStore = class {
 		this.resetFailures();
 		return {
 			ok: true,
-			message: `Applied ${operations.length} operation(s).`,
+			message: `Applied ${operations.length} operation(s).${this.storageHint(target, total)}`,
 			entries: working,
 			chars: total,
 			limit: this.limitFor(target)
@@ -762,13 +919,58 @@ var MemoryStore = class {
 		await this.write("memory", snapshot.memory);
 		await this.write("user", snapshot.user);
 	}
+	/**
+	* Detect on-disk drift: true when the file is not in the canonical
+	* `render(normalizeEntries(raw))` form. This catches structural anomalies
+	* the writer would quietly normalize away (empty/`§`-only entries, stray
+	* blank lines, leading/trailing delimiters) that indicate the file was
+	* edited outside MemoryStore. Purely single-canonical content reaches the
+	* same serialization and returns false, so a normal write is never flagged.
+	*/
 	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();
+		return render(normalizeEntries(raw)) !== raw;
 	}
 };
 //#endregion
+//#region lib/types/mutations.js
+/**
+* Curator/author audit trail: `.mutations.json` records every skill mutation
+* with before/after content hashes so any automated edit is reviewable and
+* replayable. Best-effort persistence, mirroring the usage sidecar posture.
+* @module @lmzhen/dsh-evolution-core
+*/
+const DEFAULT_MUTATION_CAP = 500;
+/** Version of the `.mutations.json` file shape; writers always emit the current one. */
+const MUTATIONS_FILE_VERSION = 1;
+function mutationsFile(root) {
+	return join(root, ".mutations.json");
+}
+function contentHash(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+async function loadMutations(root, io = nodeEvolutionIo()) {
+	const raw = await io.readText(mutationsFile(root));
+	if (raw === null) return [];
+	try {
+		const parsed = JSON.parse(raw);
+		return (Array.isArray(parsed) ? parsed : typeof parsed === "object" && parsed !== null && Array.isArray(parsed.records) ? parsed.records : []).filter((entry) => typeof entry === "object" && entry !== null && typeof entry.skillName === "string" && typeof entry.action === "string");
+	} catch {
+		return [];
+	}
+}
+/** Append one record, trim to `cap`, and write atomically (versioned shape). */
+async function recordMutation(root, io, record, cap = 500) {
+	const existing = await loadMutations(root, io);
+	existing.push(record);
+	const trimmed = existing.length > cap ? existing.slice(existing.length - cap) : existing;
+	await io.writeText(mutationsFile(root), JSON.stringify({
+		version: 1,
+		records: trimmed
+	}, null, 2));
+}
+//#endregion
 //#region lib/types/prompts.js
 /**
 * Review and curation prompts adapted from Hermes Agent
@@ -780,7 +982,13 @@ var MemoryStore = class {
 * 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";
+/**
+* Prompt bundle identity. Bump both id and version whenever a prompt's text
+* changes semantically: the bundle digest is the fail-closed signal for
+* review workers, so a stale id across deployments must be distinguishable.
+*/
+const PROMPT_BUNDLE_ID = "dsh-evolution@2";
+const PROMPT_BUNDLE_VERSION = 2;
 const MEMORY_REVIEW_PROMPT = `[Auto-review — Memory]
 Review the conversation above and consider saving to memory if appropriate.
 
@@ -825,23 +1033,54 @@ Review the conversation above and update two things.
 **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.
+const CURATOR_PROMPT = `You are the skill curator. Maintain a healthy, class-level skill library, not a flat pile of narrow one-session skills.
+
+The goal is a LIBRARY OF CLASS-LEVEL INSTRUCTIONS. A skill collection of many narrow skills where each captures one session's specific bug is a FAILURE of the library. An agent searching skills matches on descriptions, not exact names; one broad umbrella with labeled subsections beats five narrow siblings for discoverability.
 
-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.
+Right target shape: class-level skills with rich SKILL.md + references/, templates/, scripts/ support files for session-specific detail.
 
-Produce a YAML summary:
+Hard rules:
+1. NEVER hard-delete a skill. Archive (moving to .archive/) is the maximum destructive action; archives are recoverable, deletion is not.
+2. Do not touch bundled, hub-installed, pinned, or scheduled-task-referenced (\`referenced\`) skills. Referenced skills MAY be consolidated into an umbrella, but never simply pruned.
+3. Do not archive recently-created or never-used skills without strong evidence. "use=0" is NOT evidence either way — it only means the trigger has not come up yet.
+4. Do NOT reject consolidation on the grounds that "each skill has a distinct trigger". The right bar is: would a human maintainer write this as N separate skills, or one skill with N labeled subsections? When the answer is the latter, merge.
+5. Judge overlap on CONTENT, not on usage counters.
+6. Before archiving a merged skill, ensure its unique content was preserved in the umbrella.
+
+How to work:
+1. Scan the candidate list. Identify PREFIX CLUSTERS — skills sharing a first word or domain keyword (expect 10-25 clusters).
+2. For each cluster with 2+ members, ask "what is the UMBRELLA CLASS these skills serve?" and consolidate:
+   a. MERGE INTO AN EXISTING UMBRELLA (patch a labeled section for each sibling's unique insight, then archive the siblings).
+   b. CREATE A NEW UMBRELLA SKILL.md covering the shared workflow with short labeled subsections, then archive the absorbed siblings.
+   c. DEMOTE session-specific detail to references/, templates/, or scripts/ under the umbrella.
+3. Keep the umbrella body tight and scannable: exact commands, verbatim paths, ~100-200 lines; never invent flags or APIs.
+
+Produce a YAML summary with exactly this shape:
 consolidations:
   - from: <old-skill-name>
     into: <umbrella-skill-name>
     reason: <one short sentence>
 prunings:
   - name: <skill-name>
-    reason: <one short sentence>`;
+    reason: <one short sentence>
+Nominate a pruning only when archival is clearly safe (stale AND genuinely obsolete or fully absorbed elsewhere).`;
+const CURATOR_DRY_RUN_BANNER = `═══════════════════════════════════════════════════════════════
+DRY-RUN — REPORT ONLY. DO NOT MUTATE THE SKILL LIBRARY.
+═══════════════════════════════════════════════════════════════
+
+This is a PREVIEW pass. Follow every instruction above EXCEPT:
+  • Do NOT call skill_manage with action=create, update, patch, delete, write_file, or remove_file.
+  • Do NOT move, copy, or rewrite any file under the skills tree.
+
+Your output IS the deliverable: produce the exact same human-readable summary and YAML block you would on a live run, describing the actions you WOULD take. A reviewer will decide whether to approve a live run.
+
+If you accidentally take a mutating action, say so explicitly in the summary.`;
+const COMPLETION_SKILL_REVIEW_PROMPT = `[Auto-review — Skills · task complete]
+Your current task now appears complete. Before wrapping up, review the approach and update the skill library via skill_manage.
+
+Follow the skills review policy: be ACTIVE, prefer class-level umbrellas, patch skills loaded this session, and capture non-trivial techniques and user corrections. Do NOT capture environment-dependent failures, negative claims about tools, or one-off task narratives.
+
+Do NOT modify output files or re-run the task. If you are still mid-task, ignore this.`;
 function reviewPrompt(kind) {
 	if (kind === "memory") return MEMORY_REVIEW_PROMPT;
 	if (kind === "skill") return SKILL_REVIEW_PROMPT;
@@ -853,12 +1092,12 @@ function sha256(text) {
 function createPromptBundle(prompts) {
 	const canonical = JSON.stringify({
 		id: PROMPT_BUNDLE_ID,
-		version: 1,
+		version: 2,
 		prompts: Object.fromEntries(Object.entries(prompts).sort())
 	});
 	return Object.freeze({
 		id: PROMPT_BUNDLE_ID,
-		version: 1,
+		version: 2,
 		prompts: Object.freeze({ ...prompts }),
 		sha256: sha256(canonical)
 	});
@@ -867,7 +1106,8 @@ const PROMPT_BUNDLE = createPromptBundle({
 	memory: MEMORY_REVIEW_PROMPT,
 	skill: SKILL_REVIEW_PROMPT,
 	combined: COMBINED_REVIEW_PROMPT,
-	curator: CURATOR_PROMPT
+	curator: CURATOR_PROMPT,
+	completion: COMPLETION_SKILL_REVIEW_PROMPT
 });
 function verifyPromptBundle(bundle = PROMPT_BUNDLE) {
 	const canonical = JSON.stringify({
@@ -908,6 +1148,143 @@ Quality bar:
 - No router/index/hub skills that only point at other skills.
 - References go in \`references/\`, templates in \`templates/\`.`;
 //#endregion
+//#region lib/types/quality.js
+/**
+* Quality scoring and near-duplicate detection for the curated skill library.
+*
+* Pure functions over data inputs so the scoring policy is unit-testable and
+* the same math feeds the usage sidecar, the `skill_manage review` surface and
+* the learning graph. Weights follow the Hermes/hermes-claw six-factor model;
+* mutation maturity is a documented DSH approximation (single per-month patch
+* trend ratio replaces the claw timestamp-trend formula, since DSH usage
+* records only carry the last patched timestamp).
+* @module @lmzhen/dsh-evolution-core
+*/
+const QUALITY_WEIGHTS = {
+	usageFrequency: .25,
+	stability: .2,
+	recency: .2,
+	references: .1,
+	mutationMaturity: .2,
+	richness: .05
+};
+/** Score below which a skill is flagged for review. */
+const LOW_QUALITY_THRESHOLD = .3;
+function clamp01(value) {
+	return Math.max(0, Math.min(1, value));
+}
+function daysBetween(from, now) {
+	return Math.max(0, (now.getTime() - new Date(from).getTime()) / 864e5);
+}
+function computeQualityScores(input) {
+	const now = input.now ?? /* @__PURE__ */ new Date();
+	const scores = /* @__PURE__ */ new Map();
+	for (const [name, record] of input.usage) {
+		const ageDays = Math.max(1, daysBetween(record.created_at, now));
+		const idleDays = daysBetween(latestActivityAt(record) ?? record.created_at, now);
+		const patchCount = record.patch_count;
+		const useCount = record.use_count;
+		const usageFrequency = clamp01(useCount / ageDays);
+		const stability = useCount === 0 ? 1 : clamp01(1 - patchCount / useCount);
+		const recency = idleDays < 30 ? 1 : clamp01(1 - (idleDays - 30) / 150);
+		const references = clamp01((input.referenceCounts?.get(name) ?? 0) / 3);
+		const mutationMaturity = patchCount === 0 ? .3 : patchCount === 1 ? .4 : clamp01((patchCount - 1) / Math.max(1, ageDays / 30));
+		const richness = clamp01((input.supportDirs?.get(name) ?? 0) * .175);
+		const factors = {
+			usageFrequency,
+			stability,
+			recency,
+			references,
+			mutationMaturity,
+			richness
+		};
+		const score = usageFrequency * QUALITY_WEIGHTS.usageFrequency + stability * QUALITY_WEIGHTS.stability + recency * QUALITY_WEIGHTS.recency + references * QUALITY_WEIGHTS.references + mutationMaturity * QUALITY_WEIGHTS.mutationMaturity + richness * QUALITY_WEIGHTS.richness;
+		scores.set(name, {
+			score,
+			factors,
+			warn: score < LOW_QUALITY_THRESHOLD
+		});
+	}
+	return scores;
+}
+function normalize(content) {
+	return content.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function contentHash$1(content) {
+	return createHash("sha256").update(normalize(content)).digest("hex");
+}
+function tokenize(content) {
+	return new Set(normalize(content).split(/[^a-z0-9\u4e00-\u9fff]+/).filter(Boolean));
+}
+function jaccard(a, b) {
+	if (a.size === 0 || b.size === 0) return 0;
+	let intersection = 0;
+	for (const token of a) if (b.has(token)) intersection += 1;
+	return intersection / (a.size + b.size - intersection);
+}
+/**
+* Two-phase near-duplicate clustering: exact normalized-hash groups first,
+* then token-Jaccard edges at {@link DEDUP_SIMILARITY_THRESHOLD} with a token
+* ratio guard, union-find across the whole set.
+*/
+function computeDedupGroups(input) {
+	const threshold = input.threshold ?? .95;
+	const names = [...input.contents.keys()];
+	const hashes = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		const hash = contentHash$1(input.contents.get(name) ?? "");
+		const bucket = hashes.get(hash);
+		if (bucket) bucket.push(name);
+		else hashes.set(hash, [name]);
+	}
+	const parent = /* @__PURE__ */ new Map();
+	const find = (x) => {
+		const root = parent.get(x) ?? x;
+		if (root !== x) parent.set(x, find(root));
+		return parent.get(x) ?? x;
+	};
+	const union = (a, b) => {
+		const [ra, rb] = [find(a), find(b)];
+		if (ra !== rb) parent.set(rb, ra);
+	};
+	for (const [hash, bucketNames] of hashes) {
+		const first = bucketNames[0];
+		if (first === void 0 || bucketNames.length === 1) continue;
+		for (let index = 1; index < bucketNames.length; index += 1) {
+			const peer = bucketNames[index];
+			if (peer) union(first, peer);
+		}
+	}
+	const tokens = /* @__PURE__ */ new Map();
+	const tokenSet = (name) => {
+		let set = tokens.get(name);
+		if (!set) {
+			set = tokenize(input.contents.get(name) ?? "");
+			tokens.set(name, set);
+		}
+		return set;
+	};
+	for (let index = 0; index < names.length; index += 1) {
+		const a = names[index];
+		if (a === void 0) continue;
+		for (let other = index + 1; other < names.length; other += 1) {
+			const b = names[other];
+			if (b === void 0) continue;
+			const [ta, tb] = [tokenSet(a), tokenSet(b)];
+			if (Math.max(ta.size, tb.size) / Math.max(1, Math.min(ta.size, tb.size)) > 5) continue;
+			if (jaccard(ta, tb) >= threshold) union(a, b);
+		}
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		const root = find(name);
+		const group = groups.get(root);
+		if (group) group.push(name);
+		else groups.set(root, [name]);
+	}
+	return [...groups.values()].filter((group) => group.length > 1);
+}
+//#endregion
 //#region lib/types/signals.js
 /**
 * Deterministic review signal gate.
@@ -994,23 +1371,12 @@ function foldTurn(session, fromSeq) {
 * 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");
 }
@@ -1069,12 +1435,79 @@ function validateSupportPath(filePath) {
 	if (parts.length < 2) return "Provide a file name, not just a directory.";
 	return null;
 }
+/**
+* Index of `pattern` inside `content`, treating whitespace runs (spaces/tabs)
+* as flexible and literal escape sequences (`\n`, `\t`, `\r`) as their real
+* characters: a whitespace run on either side matches a run of any length on
+* the other, and a backslash-escaped char in the pattern matches the real char
+* in the content (model-copy drift). Returns the [start, end) range in the
+* ORIGINAL content so a patch can replace exactly the matched span and keep
+* every other byte intact. Returns null when no fuzzy match exists.
+*/
+function fuzzyIndexOf(content, pattern) {
+	const isSpace = (char) => char !== void 0 && /[ \t]/.test(char);
+	const escaped = (char) => {
+		if (char === "n") return "\n";
+		if (char === "t") return "	";
+		if (char === "r") return "\r";
+		return null;
+	};
+	for (let start = 0; start < content.length; start += 1) {
+		let contentIndex = start;
+		let patternIndex = 0;
+		while (patternIndex < pattern.length && contentIndex < content.length) {
+			const patternChar = pattern[patternIndex];
+			const contentChar = content[contentIndex];
+			if (isSpace(patternChar)) {
+				while (patternIndex < pattern.length && isSpace(pattern[patternIndex])) patternIndex += 1;
+				while (contentIndex < content.length && isSpace(content[contentIndex])) contentIndex += 1;
+				continue;
+			}
+			const escapedChar = patternChar === "\\" ? escaped(pattern[patternIndex + 1]) : null;
+			if (escapedChar !== null && contentChar === escapedChar) {
+				patternIndex += 2;
+				contentIndex += 1;
+				continue;
+			}
+			if (patternChar === contentChar) {
+				contentIndex += 1;
+				patternIndex += 1;
+				continue;
+			}
+			break;
+		}
+		if (patternIndex === pattern.length) return [start, contentIndex];
+	}
+	return null;
+}
+/** Trim leading whitespace of the first line and trailing whitespace of the last line. */
+function trimPatternBoundaries(pattern) {
+	const from = pattern.search(/\S/);
+	const trimmed = from < 0 ? pattern : pattern.slice(from);
+	const trailing = trimmed.search(/\s+$/);
+	return trailing < 0 ? trimmed : trimmed.slice(0, trailing);
+}
+/** Replace only the fuzzy-matched span, preserving all surrounding bytes. */
+function fuzzyReplace(content, oldString, newString, replaceAll) {
+	const match = fuzzyIndexOf(content, oldString);
+	if (match === null) return content;
+	const [start, end] = match;
+	const patched = content.slice(0, start) + newString + content.slice(end);
+	return replaceAll ? fuzzyReplace(patched, oldString, newString, true) : patched;
+}
 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);
+	const boundary = trimPatternBoundaries(oldString);
+	if (boundary !== oldString) {
+		if (fuzzyIndexOf(content, boundary) !== null) {
+			const patched = fuzzyReplace(content, boundary, newString, replaceAll);
+			return patched === content ? null : patched;
+		}
+	}
+	if (fuzzyIndexOf(content, oldString) !== null) {
+		const patched = fuzzyReplace(content, oldString, newString, replaceAll);
+		return patched === content ? null : patched;
+	}
 	return null;
 }
 var SkillLibrary = class {
@@ -1109,24 +1542,66 @@ var SkillLibrary = class {
 	async read(name) {
 		return this.io.readText(join(skillDir(this.root, name), "SKILL.md"));
 	}
-	async writeProtection(name) {
+	async writeProtection(name, origin = "foreground") {
 		const dir = skillDir(this.root, name);
 		for (const marker of ["bundled", "hub-installed"]) if (await this.io.exists(markerPath(dir, marker))) return marker;
+		if (origin === "background_review" && await this.io.exists(markerPath(dir, "pinned"))) return "pinned";
 		return null;
 	}
-	async deleteProtection(name) {
+	async deleteProtection(name, options = {}) {
 		const dir = skillDir(this.root, name);
-		for (const marker of [
+		const markers = options.allowBundled ? ["hub-installed", "pinned"] : [
 			"bundled",
 			"hub-installed",
 			"pinned"
-		]) if (await this.io.exists(markerPath(dir, marker))) return marker;
+		];
+		for (const marker of markers) 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"));
 	}
+	/** Whether the skill carries the bundled marker (curator prune-builtins eligibility). */
+	async isBundled(name) {
+		const dir = skillDir(this.root, name);
+		return await this.io.exists(markerPath(dir, "bundled"));
+	}
+	/** Count non-empty support subdirectories (richness input for quality scoring). */
+	async countSupportDirs(name) {
+		const dir = skillDir(this.root, name);
+		let entries;
+		try {
+			entries = await this.io.list(dir);
+		} catch {
+			return 0;
+		}
+		let count = 0;
+		for (const subdir of SUPPORT_DIRS) {
+			if (!entries.includes(subdir)) continue;
+			try {
+				if ((await this.io.list(join(dir, subdir))).some((file) => file !== ".gitkeep")) count += 1;
+			} catch {}
+		}
+		return count;
+	}
+	/** Best-effort audit trail entry; never blocks the mutation. */
+	async audit(skillName, action, before, after, summary) {
+		try {
+			await recordMutation(this.root, this.io, {
+				skillName,
+				action,
+				...before === null ? {} : { beforeHash: contentHash(before) },
+				...after === null ? {} : { afterHash: contentHash(after) },
+				summary,
+				at: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		} catch {}
+	}
+	/** Recent mutation audit records (read-only inspection surface). */
+	async listMutations() {
+		return await loadMutations(this.root, this.io);
+	}
 	async create(name, content, origin) {
 		const normalized = name.trim();
 		if (!SKILL_NAME_RE.test(normalized) || normalized.length > this.limits.maxNameLength) return {
@@ -1150,19 +1625,21 @@ var SkillLibrary = class {
 		};
 		await this.io.writeText(join(dir, "SKILL.md"), content.trimEnd() + "\n");
 		if (origin === "background_review") await this.io.writeText(markerPath(dir, "hermes-managed"), "");
+		await this.audit(normalized, "create", null, content, "created");
 		return {
 			ok: true,
 			message: `Skill "${normalized}" created.`,
 			path: dir
 		};
 	}
-	async update(name, content) {
+	async update(name, content, origin = "foreground") {
 		const dir = skillDir(this.root, name);
-		if (!await this.io.readText(join(dir, "SKILL.md"))) return {
+		const md = await this.io.readText(join(dir, "SKILL.md"));
+		if (!md) return {
 			ok: false,
 			message: `Skill "${name}" not found.`
 		};
-		const protection = await this.writeProtection(name);
+		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
 			message: `Skill "${name}" is protected (${protection}).`
@@ -1178,20 +1655,21 @@ var SkillLibrary = class {
 			message: threat
 		};
 		await this.io.writeText(join(dir, "SKILL.md"), content.trimEnd() + "\n");
+		await this.audit(name, "update", md, content, "updated");
 		return {
 			ok: true,
 			message: `Skill "${name}" updated.`,
 			path: dir
 		};
 	}
-	async patch(name, oldString, newString, filePath = "", replaceAll = false) {
+	async patch(name, oldString, newString, filePath = "", replaceAll = false, origin = "foreground") {
 		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);
+		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
 			message: `Skill "${name}" is protected (${protection}).`
@@ -1238,27 +1716,29 @@ var SkillLibrary = class {
 			message: threat
 		};
 		await this.io.writeText(target, patched.trimEnd() + "\n");
+		await this.audit(name, "patch", md, patched, `patched ${patchLabel}`);
 		return {
 			ok: true,
 			message: `Skill "${name}" patched (${patchLabel}).`,
 			path: dir
 		};
 	}
-	async archive(name, absorbedInto = "") {
+	async archive(name, options = {}) {
 		const dir = skillDir(this.root, name);
-		if (!await this.io.readText(join(dir, "SKILL.md"))) return {
+		const md = await this.io.readText(join(dir, "SKILL.md"));
+		if (!md) return {
 			ok: false,
 			message: `Skill "${name}" not found.`
 		};
-		const protection = await this.deleteProtection(name);
+		const protection = await this.deleteProtection(name, options.allowBundled === void 0 ? {} : { allowBundled: options.allowBundled });
 		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 {
+		if (options.absorbedInto) {
+			if (!await this.io.readText(join(skillDir(this.root, options.absorbedInto), "SKILL.md"))) return {
 				ok: false,
-				message: `absorbed_into="${absorbedInto}" does not exist.`
+				message: `absorbed_into="${options.absorbedInto}" does not exist.`
 			};
 		}
 		const archiveRoot = join(this.root, ".archive");
@@ -1270,21 +1750,144 @@ var SkillLibrary = class {
 			await this.io.copy(dir, dest);
 			await this.io.remove(dir);
 		}
-		const reason = absorbedInto ? `Consolidated into ${absorbedInto}` : "Archived by self-evolution curator";
+		const reason = options.reason ?? (options.absorbedInto ? `Consolidated into ${options.absorbedInto}` : "Archived by self-evolution curator");
 		await this.io.writeText(join(dest, ".archive-reason"), `${(/* @__PURE__ */ new Date()).toISOString()}: ${reason}\n`);
+		await this.audit(name, "archive", md, null, reason);
 		return {
 			ok: true,
 			message: `Skill "${name}" archived to .archive.`,
 			path: dest
 		};
 	}
-	async writeSupportFile(name, filePath, content) {
+	/**
+	* Merge the bodies of `sources` into `target` and archive the sources with
+	* an absorbed-into marker. Hermes-style consolidation: overlapping skills
+	* collapse into one, and the originals stay recoverable under `.archive/`.
+	*/
+	async consolidate(target, sources, origin = "foreground") {
+		const normalizedSources = [...new Set(sources)].filter((name) => name !== target);
+		if (normalizedSources.length === 0) return {
+			ok: false,
+			message: "Consolidation requires at least one distinct source skill."
+		};
+		for (const name of [target, ...normalizedSources]) if (!SKILL_NAME_RE.test(name)) return {
+			ok: false,
+			message: `Invalid skill name "${name}". Use lowercase letters, digits, and hyphens.`
+		};
+		const targetDir = skillDir(this.root, target);
+		const targetMd = await this.io.readText(join(targetDir, "SKILL.md"));
+		if (!targetMd) return {
+			ok: false,
+			message: `Skill "${target}" not found.`
+		};
+		const targetProtection = await this.writeProtection(target, origin);
+		if (targetProtection) return {
+			ok: false,
+			message: `Skill "${target}" is protected (${targetProtection}).`
+		};
+		const parts = [];
+		for (const source of normalizedSources) {
+			const protection = await this.deleteProtection(source);
+			if (protection) return {
+				ok: false,
+				message: `Skill "${source}" is protected (${protection}).`
+			};
+			const sourceMd = await this.io.readText(join(skillDir(this.root, source), "SKILL.md"));
+			if (!sourceMd) return {
+				ok: false,
+				message: `Skill "${source}" not found.`
+			};
+			const parsed = parseFrontmatter(sourceMd);
+			if (!parsed) return {
+				ok: false,
+				message: `Skill "${source}" has no valid frontmatter; refusing to merge.`
+			};
+			parts.push(`\n<!-- consolidated from ${source} at ${(/* @__PURE__ */ new Date()).toISOString()} -->\n${parsed.body.trim()}`);
+		}
+		const merged = targetMd.trimEnd() + parts.join("\n") + "\n";
+		const validation = validateFrontmatter(merged, target, this.limits);
+		if (validation) return {
+			ok: false,
+			message: `Consolidation rejected: ${validation}`
+		};
+		const threat = scanContentThreats(merged);
+		if (threat) return {
+			ok: false,
+			message: threat
+		};
+		const archived = [];
+		try {
+			for (const source of normalizedSources) {
+				const result = await this.archive(source, { absorbedInto: target });
+				if (!result.ok) return result;
+				archived.push(source);
+			}
+			await this.io.writeText(join(targetDir, "SKILL.md"), merged);
+		} catch (error) {
+			await this.io.writeText(join(targetDir, "SKILL.md"), targetMd).catch(() => {});
+			for (const source of archived.reverse()) await this.restoreFromArchive(source).catch(() => {});
+			return {
+				ok: false,
+				message: `Consolidation failed and was rolled back: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+		return {
+			ok: true,
+			message: `Consolidated ${normalizedSources.join(", ")} into "${target}".`,
+			path: targetDir
+		};
+	}
+	/**
+	* Restore one skill from `.archive/` back to the active root. Hermes-style
+	* recoverability: archival never deletes, and this is the control-plane
+	* path back. The `.archive-reason` marker is dropped on restore.
+	*/
+	async restoreFromArchive(name) {
+		if (!SKILL_NAME_RE.test(name)) return {
+			ok: false,
+			message: `Invalid skill name "${name}". Use lowercase letters, digits, and hyphens.`
+		};
+		if (await this.io.exists(join(skillDir(this.root, name), "SKILL.md"))) return {
+			ok: false,
+			message: `Skill "${name}" already exists in the active root; refusing to overwrite.`
+		};
+		const archiveRoot = join(this.root, ".archive");
+		let entries;
+		try {
+			entries = await this.io.list(archiveRoot);
+		} catch {
+			return {
+				ok: false,
+				message: "No skill archive available."
+			};
+		}
+		const chosen = entries.filter((entry) => entry === name || entry.startsWith(`${name}-`)).sort().reverse()[0];
+		if (!chosen) return {
+			ok: false,
+			message: `Skill "${name}" is not in .archive.`
+		};
+		const source = join(archiveRoot, chosen);
+		const dest = skillDir(this.root, name);
+		try {
+			await this.io.rename(source, dest);
+		} catch {
+			await this.io.copy(source, dest);
+			await this.io.remove(source);
+		}
+		if (await this.io.exists(join(dest, ".archive-reason"))) await this.io.remove(join(dest, ".archive-reason"));
+		return {
+			ok: true,
+			message: `Skill "${name}" restored from .archive.`,
+			path: dest
+		};
+	}
+	async writeSupportFile(name, filePath, content, origin = "foreground") {
 		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);
+		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
 			message: `Skill "${name}" is protected (${protection}).`
@@ -1304,20 +1907,22 @@ var SkillLibrary = class {
 			message: threat
 		};
 		const target = join(dir, ...filePath.replace(/\\/g, "/").split("/").filter(Boolean));
+		const existing = await this.io.readText(target).catch(() => null);
 		await this.io.writeText(target, content);
+		await this.audit(name, "write_file", existing, content, `wrote ${filePath}`);
 		return {
 			ok: true,
 			message: `Support file "${filePath}" written to "${name}".`,
 			path: target
 		};
 	}
-	async removeSupportFile(name, filePath) {
+	async removeSupportFile(name, filePath, origin = "foreground") {
 		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);
+		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
 			message: `Skill "${name}" is protected (${protection}).`
@@ -1332,7 +1937,9 @@ var SkillLibrary = class {
 			ok: false,
 			message: `File "${filePath}" not found in skill "${name}".`
 		};
+		const before = await this.io.readText(target).catch(() => null);
 		await this.io.remove(target);
+		await this.audit(name, "remove_file", before, null, `removed ${filePath}`);
 		return {
 			ok: true,
 			message: `Support file "${filePath}" removed from "${name}".`,
@@ -1403,7 +2010,7 @@ var SkillLibrary = class {
 function evolutionHome(env = process.env) {
 	return join(env.DSH_HOME ?? join(homedir(), ".dsh"), "evolution");
 }
-var JsonState = class {
+var JsonState = class JsonState {
 	initial;
 	path;
 	value;
@@ -1412,14 +2019,24 @@ var JsonState = class {
 		this.path = join(evolutionHome(env), name);
 		this.value = this.loadSync();
 	}
+	/**
+	* Deep-merge persisted state over the initial defaults. Nested plain
+	* objects merge recursively (so a new default field added under an existing
+	* object is preserved), while arrays and primitives take the on-disk value
+	* wholesale. Keeps forward-compatible defaults across schema additions.
+	*/
+	static mergeDeep(initial, persisted) {
+		const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+		if (!isRecord(initial) || !isRecord(persisted)) return isRecord(persisted) ? persisted : persisted == null ? initial : persisted;
+		const out = { ...initial };
+		for (const [key, value] of Object.entries(persisted)) out[key] = key in initial ? JsonState.mergeDeep(initial[key], value) : value;
+		return out;
+	}
 	loadSync() {
 		try {
 			const raw = readFileSync(this.path, "utf8");
 			const parsed = JSON.parse(raw);
-			return {
-				...this.initial,
-				...parsed
-			};
+			return JsonState.mergeDeep(this.initial, parsed);
 		} catch {
 			return { ...this.initial };
 		}
@@ -1443,14 +2060,11 @@ var JsonState = class {
 	async reload() {
 		try {
 			const raw = await readFile(this.path, "utf8");
-			this.value = {
-				...this.initial,
-				...JSON.parse(raw)
-			};
+			this.value = JsonState.mergeDeep(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 };
+export { COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_USER_CHAR_LIMIT, DSH_AUTHORING_STANDARDS, ENTRY_DELIMITER, JsonState, LOW_QUALITY_THRESHOLD, MAX_DESCRIPTION_LENGTH, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MEMORY_REVIEW_PROMPT, MUTATIONS_FILE_VERSION, MemoryStore, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, QUALITY_WEIGHTS, SKILL_NAME_RE, SKILL_REVIEW_PROMPT, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, advanceReview, buildCuratorRunReport, bumpPatch, bumpUse, bumpView, computeDedupGroups, computeLifecycleTransitions, computeQualityScores, contentHash, emptyRecord, evaluateThreat, evolutionHome, evolutionIoAdapter, foldTurn, getRecord, latestActivityAt, loadMutations, loadSuppressedNames, loadUsage, markAgentCreated, memoryRoot, mutationsFile, nodeEvolutionIo, observeEvent, parseCuratorNominations, parseFrontmatter, recordMutation, reviewPrompt, saveSuppressedNames, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, skillsRoot, suppressedFile, usageFile, validateFrontmatter, verifyPromptBundle };