@lmzhen/dsh-evolution-core 0.1.0-rc.11 → 0.1.0-rc.13

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";
@@ -151,13 +151,87 @@ 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.
+*/
+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);
+		if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
+		return new Set(parsed.filter((entry) => typeof entry === "string"));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+async function saveSuppressedNames(root, names, io = nodeEvolutionIo()) {
+	await io.writeText(suppressedFile(root), JSON.stringify([...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;
+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 {
 		runId: input.runId,
@@ -184,7 +258,9 @@ 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;
+		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());
@@ -471,7 +547,6 @@ function scanContentThreats(text, maxScanChars = 65536, options = NO_SCAN_OPTION
 * 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 +609,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 +655,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 +668,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 +707,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 +740,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 +754,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 +836,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)
@@ -1002,23 +1107,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");
 }
@@ -1117,24 +1211,31 @@ 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"));
+	}
 	async create(name, content, origin) {
 		const normalized = name.trim();
 		if (!SKILL_NAME_RE.test(normalized) || normalized.length > this.limits.maxNameLength) return {
@@ -1164,13 +1265,13 @@ var SkillLibrary = class {
 			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 {
 			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}).`
@@ -1192,14 +1293,14 @@ var SkillLibrary = class {
 			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}).`
@@ -1252,21 +1353,21 @@ var SkillLibrary = class {
 			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 {
 			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");
@@ -1278,7 +1379,7 @@ 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`);
 		return {
 			ok: true,
@@ -1291,7 +1392,7 @@ var SkillLibrary = class {
 	* an absorbed-into marker. Hermes-style consolidation: overlapping skills
 	* collapse into one, and the originals stay recoverable under `.archive/`.
 	*/
-	async consolidate(target, sources) {
+	async consolidate(target, sources, origin = "foreground") {
 		const normalizedSources = [...new Set(sources)].filter((name) => name !== target);
 		if (normalizedSources.length === 0) return {
 			ok: false,
@@ -1307,7 +1408,7 @@ var SkillLibrary = class {
 			ok: false,
 			message: `Skill "${target}" not found.`
 		};
-		const targetProtection = await this.writeProtection(target);
+		const targetProtection = await this.writeProtection(target, origin);
 		if (targetProtection) return {
 			ok: false,
 			message: `Skill "${target}" is protected (${targetProtection}).`
@@ -1345,7 +1446,7 @@ var SkillLibrary = class {
 		const archived = [];
 		try {
 			for (const source of normalizedSources) {
-				const result = await this.archive(source, target);
+				const result = await this.archive(source, { absorbedInto: target });
 				if (!result.ok) return result;
 				archived.push(source);
 			}
@@ -1408,13 +1509,13 @@ var SkillLibrary = class {
 			path: dest
 		};
 	}
-	async writeSupportFile(name, filePath, content) {
+	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}).`
@@ -1441,13 +1542,13 @@ var SkillLibrary = class {
 			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}).`
@@ -1590,4 +1691,4 @@ var JsonState = class JsonState {
 	}
 };
 //#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, 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, CURATOR_PROMPT, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MIN_IDLE_HOURS, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, 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, 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, computeLifecycleTransitions, emptyRecord, evaluateThreat, evolutionHome, evolutionIoAdapter, foldTurn, getRecord, latestActivityAt, loadSuppressedNames, loadUsage, markAgentCreated, memoryRoot, nodeEvolutionIo, observeEvent, parseFrontmatter, reviewPrompt, saveSuppressedNames, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, skillsRoot, suppressedFile, usageFile, validateFrontmatter, verifyPromptBundle };

package/lib/types/constants.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 @deepseek-ai/dsh-evolution-core
+ */
+/** Skill frontmatter `name` validated for the file name (lowercase + hyphen). */
+export declare const SKILL_NAME_RE: RegExp;
+/** Allowed skill support-file subdirectories (path-traversal boundary). */
+export declare const SUPPORT_DIRS: readonly ["references", "templates", "scripts", "assets"];
+/** Delimiter between durable memory entries (on-disk storage format). */
+export declare const ENTRY_DELIMITER = "\n\u00A7\n";
+/** Built-in skill names the curator must never lifecycle-manage. */
+export declare const PROTECTED_BUILTIN_SKILLS: ReadonlySet<string>;
+export declare const MAX_SKILL_NAME_LENGTH = 64;
+export declare const MAX_DESCRIPTION_LENGTH = 1024;
+export declare const MAX_SKILL_CONTENT_CHARS = 100000;
+export declare const MAX_SKILL_FILE_BYTES = 1048576;
+export declare const DEFAULT_REVIEW_MEMORY_INTERVAL = 10;
+export declare const DEFAULT_REVIEW_SKILL_INTERVAL = 10;
+export declare const DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS = 3;
+export declare const DEFAULT_SUBSTANTIVE_MIN_USER_CHARS = 200;
+export declare const DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS = 500;
+export declare const DEFAULT_MAX_OPS_PER_PLAN = 32;
+export declare const DEFAULT_CURATOR_INTERVAL_HOURS = 168;
+export declare const DEFAULT_MIN_IDLE_HOURS = 2;
+export declare const DEFAULT_STALE_AFTER_DAYS = 30;
+export declare const DEFAULT_ARCHIVE_AFTER_DAYS = 90;
+export declare const DEFAULT_MEMORY_CHAR_LIMIT = 2200;
+export declare const DEFAULT_USER_CHAR_LIMIT = 1375;
+export declare const DEFAULT_SKILL_CONTENT_CHARS = 100000;
+//# sourceMappingURL=constants.d.ts.map

package/lib/types/curator.d.ts

@@ -3,6 +3,7 @@
  * Pure function; file moves are performed by SkillLibrary.
  */
 import type { UsageMap } from './usage.ts';
+export { PROTECTED_BUILTIN_SKILLS } from './constants.ts';
 export interface CuratorConfig {
     staleAfterDays: number;
     archiveAfterDays: number;
@@ -12,6 +13,12 @@ export interface CuratorConfig {
     excludeSkillNames?: ReadonlySet<string>;
     /** When true, usage records without created_by='agent' also enter the lifecycle. */
     manageUnmanaged?: boolean;
+    /** When true, bundled skills (in `bundledNames`) are curation candidates like agent-created ones. */
+    pruneBuiltins?: boolean;
+    /** Skill names carrying the bundled marker; only read when `pruneBuiltins` is true. */
+    bundledNames?: ReadonlySet<string>;
+    /** Skill names the curator archived once and must not fight across re-seeds. */
+    suppressedNames?: ReadonlySet<string>;
 }
 export interface CuratorTransition {
     name: string;
@@ -25,7 +32,6 @@ export interface CuratorResult {
     reactivate: string[];
     markStale: string[];
 }
-export declare const PROTECTED_BUILTIN_SKILLS: ReadonlySet<string>;
 export interface CuratorArchivedSkill {
     name: string;
     path: string;

package/lib/types/index.d.ts

@@ -17,4 +17,5 @@ export * from './skill-store.ts';
 export * from './state-store.ts';
 export * from './threats.ts';
 export * from './usage.ts';
+export * from './constants.ts';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/memory-store.d.ts

@@ -3,7 +3,7 @@
  * Stores are MEMORY.md and USER.md under $DSH_HOME/memories (~/.dsh/memories).
  */
 import { type EvolutionIoLike } from './io.ts';
-export declare const ENTRY_DELIMITER = "\n\u00A7\n";
+export { ENTRY_DELIMITER } from './constants.ts';
 export type MemoryTarget = 'memory' | 'user';
 export interface MemoryOperation {
     action: 'add' | 'replace' | 'remove';
@@ -41,6 +41,14 @@ export declare class MemoryStore {
     write(target: MemoryTarget, entries: string[]): Promise<void>;
     resetFailures(): void;
     private failure;
+    /** Percent-based storage hint appended to success message once the target is ≥80% full. */
+    private storageHint;
+    /**
+     * 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.
+     */
+    private backupDrift;
     add(target: MemoryTarget, facts: string): Promise<MemoryApplyResult>;
     replace(target: MemoryTarget, oldText: string, facts: string): Promise<MemoryApplyResult>;
     remove(target: MemoryTarget, oldText: string): Promise<MemoryApplyResult>;

package/lib/types/skill-store.d.ts

@@ -7,11 +7,6 @@
  * move to `.archive/` — never a hard delete.
  */
 import { type EvolutionIoLike } from './io.ts';
-export declare const SKILL_NAME_RE: RegExp;
-export declare const MAX_SKILL_NAME_LENGTH = 64;
-export declare const MAX_DESCRIPTION_LENGTH = 1024;
-export declare const MAX_SKILL_CONTENT_CHARS = 100000;
-export declare const MAX_SKILL_FILE_BYTES = 1048576;
 export interface SkillLimits {
     maxNameLength: number;
     maxDescriptionLength: number;
@@ -19,7 +14,6 @@ export interface SkillLimits {
     maxSkillFileBytes: number;
 }
 export declare const DEFAULT_SKILL_LIMITS: SkillLimits;
-export declare const SUPPORT_DIRS: readonly ["references", "templates", "scripts", "assets"];
 export interface SkillSummary {
     name: string;
     description: string;
@@ -33,6 +27,17 @@ export interface SkillActionResult {
     message: string;
     path?: string;
 }
+/** Who is writing: a foreground user-directed tool call, or the autonomous review/curator pipeline. */
+export type WriteOrigin = 'foreground' | 'background_review';
+/** Options for `SkillLibrary.archive`. The absorbed-into name and the archival reason are distinct fields. */
+export interface ArchiveOptions {
+    /** Umbrella skill this one was consolidated into; when set it must exist (consolidate semantics). */
+    absorbedInto?: string;
+    /** Human-readable reason written to `.archive-reason`; default derives from `absorbedInto`. */
+    reason?: string;
+    /** Permit archiving a bundled skill (curator prune-builtins only; hub-installed and pinned stay protected). */
+    allowBundled?: boolean;
+}
 export declare function skillsRoot(env?: NodeJS.ProcessEnv): string;
 export interface Frontmatter {
     name?: string;
@@ -51,27 +56,31 @@ export declare class SkillLibrary {
     constructor(root?: string, io?: EvolutionIoLike, limits?: SkillLimits);
     list(): Promise<SkillSummary[]>;
     read(name: string): Promise<string | null>;
-    writeProtection(name: string): Promise<string | null>;
-    deleteProtection(name: string): Promise<string | null>;
+    writeProtection(name: string, origin?: WriteOrigin): Promise<string | null>;
+    deleteProtection(name: string, options?: {
+        allowBundled?: boolean;
+    }): Promise<string | null>;
     isManaged(name: string): Promise<boolean>;
+    /** Whether the skill carries the bundled marker (curator prune-builtins eligibility). */
+    isBundled(name: string): Promise<boolean>;
     create(name: string, content: string, origin: 'foreground' | 'background_review'): Promise<SkillActionResult>;
-    update(name: string, content: string): Promise<SkillActionResult>;
-    patch(name: string, oldString: string, newString: string, filePath?: string, replaceAll?: boolean): Promise<SkillActionResult>;
-    archive(name: string, absorbedInto?: string): Promise<SkillActionResult>;
+    update(name: string, content: string, origin?: WriteOrigin): Promise<SkillActionResult>;
+    patch(name: string, oldString: string, newString: string, filePath?: string, replaceAll?: boolean, origin?: WriteOrigin): Promise<SkillActionResult>;
+    archive(name: string, options?: ArchiveOptions): Promise<SkillActionResult>;
     /**
      * 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/`.
      */
-    consolidate(target: string, sources: string[]): Promise<SkillActionResult>;
+    consolidate(target: string, sources: string[], origin?: WriteOrigin): Promise<SkillActionResult>;
     /**
      * 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.
      */
     restoreFromArchive(name: string): Promise<SkillActionResult>;
-    writeSupportFile(name: string, filePath: string, content: string): Promise<SkillActionResult>;
-    removeSupportFile(name: string, filePath: string): Promise<SkillActionResult>;
+    writeSupportFile(name: string, filePath: string, content: string, origin?: WriteOrigin): Promise<SkillActionResult>;
+    removeSupportFile(name: string, filePath: string, origin?: WriteOrigin): Promise<SkillActionResult>;
     snapshotAll(reason?: string): Promise<string>;
     listSnapshots(): Promise<Array<{
         path: string;

package/lib/types/usage.d.ts

@@ -30,4 +30,12 @@ export declare function bumpUse(map: UsageMap, name: string, when?: Date): void;
 export declare function bumpPatch(map: UsageMap, name: string, when?: Date): void;
 export declare function markAgentCreated(map: UsageMap, name: string): void;
 export declare function latestActivityAt(record: UsageRecord): string | 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.
+ */
+export declare function suppressedFile(root: string): string;
+export declare function loadSuppressedNames(root: string, io?: EvolutionIoLike): Promise<ReadonlySet<string>>;
+export declare function saveSuppressedNames(root: string, names: ReadonlySet<string>, io?: EvolutionIoLike): Promise<void>;
 //# sourceMappingURL=usage.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-core",
   "description": "Shared stores, prompts, signals and lifecycle logic for the dsh-evolution plugin family (community build)",
-  "version": "0.1.0-rc.11",
+  "version": "0.1.0-rc.13",
   "publishConfig": {
     "access": "public"
   },