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

package/lib/index.js

@@ -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
 /**
@@ -417,10 +413,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 +431,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 +444,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.`;
 }
@@ -762,10 +762,18 @@ 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
@@ -1278,6 +1286,128 @@ var SkillLibrary = class {
 			path: dest
 		};
 	}
+	/**
+	* 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) {
+		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);
+		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, 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) {
 		const dir = skillDir(this.root, name);
 		if (!await this.io.exists(join(dir, "SKILL.md"))) return {
@@ -1403,7 +1533,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 +1542,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 +1583,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, 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 };

package/lib/types/io.d.ts

@@ -17,6 +17,4 @@ export interface EvolutionIoLike {
 /** Lazy adapter over an IO provider registry, shared by every evolution consumer. */
 export declare function evolutionIoAdapter(provider: () => EvolutionIoLike): EvolutionIoLike;
 export declare function nodeEvolutionIo(): EvolutionIoLike;
-/** Absolute path helper kept separate so stores stay platform-correct. */
-export declare function childPath(parent: string, ...parts: string[]): string;
 //# sourceMappingURL=io.d.ts.map

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

@@ -55,6 +55,14 @@ export declare class MemoryStore {
         memory: string[];
         user: string[];
     }): Promise<void>;
+    /**
+     * 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.
+     */
     detectDrift(target: MemoryTarget): Promise<boolean>;
 }
 //# sourceMappingURL=memory-store.d.ts.map

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

@@ -58,6 +58,18 @@ export declare class SkillLibrary {
     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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
     snapshotAll(reason?: string): Promise<string>;

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

@@ -8,6 +8,13 @@ export declare class JsonState<T> {
     readonly path: string;
     private value;
     constructor(name: string, initial: T, env?: NodeJS.ProcessEnv);
+    /**
+     * 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.
+     */
+    private static mergeDeep;
     private loadSync;
     get(): T;
     set(value: T): void;

package/lib/types/threats.d.ts

@@ -12,17 +12,29 @@ export interface ThreatFinding {
     category: string;
     scope: ThreatScope;
 }
+/**
+ * Optional scan controls. Default behavior (`options` omitted) is unchanged:
+ * every in-scope pattern blocks. Adapters that need to tolerate a specific
+ * benign phrasing (e.g. a skill that legitimately opens with "You are now a ...")
+ * can exclude that label by name here. This is opt-in and never widens strict
+ * scope; it only permits callers to drop a known-innocent match.
+ */
+export interface ScanOptions {
+    /** Pattern labels to skip during this scan. */
+    excludeLabels?: readonly string[];
+}
 /**
  * Scan text at `scope`. Patterns are cumulative: `strict` includes all scopes.
+ * `options.excludeLabels` removes matching patterns without changing `scope`.
  */
-export declare function scanThreats(text: string, scope?: ThreatScope, maxScanChars?: number): ThreatFinding[];
+export declare function scanThreats(text: string, scope?: ThreatScope, maxScanChars?: number, options?: ScanOptions): ThreatFinding[];
 /** Blocking policy: any hit blocks. `severity` is deliberately not a gate. */
-export declare function evaluateThreat(text: string, scope?: ThreatScope, maxScanChars?: number): {
+export declare function evaluateThreat(text: string, scope?: ThreatScope, maxScanChars?: number, options?: ScanOptions): {
     blocked: boolean;
     findings: ThreatFinding[];
 };
 /** User-facing block message for memory writes. */
-export declare function scanMemoryThreats(text: string, maxScanChars?: number): string | null;
+export declare function scanMemoryThreats(text: string, maxScanChars?: number, options?: ScanOptions): string | null;
 /** User-facing block message for skill content writes. */
-export declare function scanContentThreats(text: string, maxScanChars?: number): string | null;
+export declare function scanContentThreats(text: string, maxScanChars?: number, options?: ScanOptions): string | null;
 //# sourceMappingURL=threats.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.1",
+  "version": "0.1.0-rc.11",
   "publishConfig": {
     "access": "public"
   },