@lmzhen/dsh-evolution-curator 0.1.0-rc.4 → 0.1.0-rc.40

package/README.md

@@ -21,4 +21,17 @@ Independent of request-prefix construction. This package does not alter the asse
 ## Known Limitations and Deferred Work
 
 
-- - LLM nomination pass is advisory and disabled by default; deterministic lifecycle remains authoritative.
+- LLM nomination pass is advisory and disabled by default; deterministic lifecycle remains authoritative.
+- Consolidation is control-plane only (`/evolution consolidate <target> <source...>`): no LLM pass proposes merge groups yet, and merged source bodies are appended verbatim rather than rewritten into a synthesized skill.
+
+## Recovery and consolidation
+
+- `archive` never deletes: skills move to `.archive/` with a `.archive-reason` marker.
+- `restore(name)` (service) / `/evolution skill restore <name>` brings one archived skill back to the active root and resets its usage state.
+- `consolidate(target, sources)` (service) / `/evolution consolidate` merges source bodies into the target, archives the sources with an absorbed-into marker, and folds their usage records into `archived` state. Both operations snapshot the full state first (`pre-consolidate` / `pre-restore`).
+- `restoreSnapshot` (service) / `/evolution restore` rolls the FULL state back to the latest snapshot: active tree, usage/suppression sidecars, `.archive/` and the curator state carried in the snapshot (`curator-state.json`), so the interval gate does not immediately re-fire after a rollback. The restore itself is undoable — the pre-rollback safety snapshot preserves the current tree plus its state.
+
+## Automatic scheduling
+
+- `autoStart` (default true) arms an hourly interval check plus a deferred catch-up check `bootGraceSeconds` (default 10) after host boot. Both decide due-ness from the **persisted** `lastRunAt`, so a restart with an overdue schedule runs the first pass within the boot grace instead of waiting a full interval. `bootGraceSeconds: 0` disables the deferral (not recommended: the check may run against a half-mounted host). All scheduling gates — interval, idle, first-run deferral, and the reentrancy guard — remain inside `run()`.
+- `autoStart: false` disables both automatic checks; `/evolution curator run` (manual, gate-skipping) still works.

package/lib/index.js

@@ -3,25 +3,39 @@ import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
 import z from "@deepseek-ai/schemastery";
-import { CURATOR_PROMPT, SkillLibrary, buildCuratorRunReport, computeLifecycleTransitions, evolutionHome, evolutionIoAdapter, loadUsage, saveUsage } from "@lmzhen/dsh-evolution-core";
+import { CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_MIN_IDLE_HOURS, DEFAULT_STALE_AFTER_DAYS, SKILL_NAME_RE, SkillLibrary, buildCuratorRunReport, computeLifecycleTransitions, computeQualityScores, computeScopeView, emptyRecord, evolutionHome, evolutionIoAdapter, loadSuppressedNames, loadUsage, parseCuratorNominations, parseFrontmatter, saveSuppressedNames, saveUsage } from "@lmzhen/dsh-evolution-core";
 //#region lib/types/index.js
 /**
 * Deterministic skill lifecycle curator with interval gate and archive.
 * @module @lmzhen/dsh-evolution-curator
 */
+/**
+* Block LLM-nominated consolidations that would touch a gate-protected name:
+* exclude / referenced / suppressed skills must never merge (neither as the
+* source being archived nor as the umbrella being edited). Mirrors the control
+* plane's `consolidate()` guard; automatic nominations must pass the same gate.
+*/
+function gateConsolidations(consolidations, gates) {
+	const blocked = (name) => gates.exclude?.has(name) === true || gates.referenced?.has(name) === true || gates.suppressed?.has(name) === true;
+	return consolidations.filter((n) => !blocked(n.from) && !blocked(n.into));
+}
 var EvolutionCurator = class extends Service {
 	static inject = ["evolutionIo"];
 	static Config = z.object({
 		enabled: z.boolean().default(true),
-		intervalHours: z.number().default(168),
-		staleAfterDays: z.number().default(30),
-		archiveAfterDays: z.number().default(90),
+		intervalHours: z.number().default(DEFAULT_CURATOR_INTERVAL_HOURS),
+		staleAfterDays: z.number().default(DEFAULT_STALE_AFTER_DAYS),
+		archiveAfterDays: z.number().default(DEFAULT_ARCHIVE_AFTER_DAYS),
 		llmReview: z.boolean().default(false),
 		curatorProvider: z.string().default("deepseek-official"),
 		qualityWarnStaleAfterDays: z.number().default(7),
-		minIdleHours: z.number().default(0),
+		minIdleHours: z.number().default(DEFAULT_MIN_IDLE_HOURS),
 		excludeSkillNames: z.array(z.string()).default([]),
 		manageUnmanaged: z.boolean().default(false),
+		pruneBuiltins: z.boolean().default(false),
+		referencedSkillNames: z.array(z.string()).default([]),
+		autoStart: z.boolean().default(true),
+		bootGraceSeconds: z.number().default(10),
 		curatorReviewMaxTokens: z.number().default(2048)
 	});
 	skills;
@@ -36,23 +50,31 @@ var EvolutionCurator = class extends Service {
 	minIdleHours;
 	excludeSkillNames;
 	manageUnmanaged;
+	pruneBuiltins;
+	referencedSkillNames;
+	bootGraceSeconds;
 	curatorReviewMaxTokens;
 	lastRun = 0;
 	timer;
+	bootCheck;
+	running = false;
 	constructor(ctx, config = {}) {
 		super(ctx, "evolutionCurator");
 		this.io = evolutionIoAdapter(() => ctx.evolutionIo.provider());
 		this.skills = new SkillLibrary(void 0, this.io);
 		this.enabled = config.enabled ?? true;
-		this.intervalHours = config.intervalHours ?? 168;
-		this.staleAfterDays = config.staleAfterDays ?? 30;
-		this.archiveAfterDays = config.archiveAfterDays ?? 90;
+		this.intervalHours = config.intervalHours ?? DEFAULT_CURATOR_INTERVAL_HOURS;
+		this.staleAfterDays = config.staleAfterDays ?? DEFAULT_STALE_AFTER_DAYS;
+		this.archiveAfterDays = config.archiveAfterDays ?? DEFAULT_ARCHIVE_AFTER_DAYS;
 		this.llmReview = config.llmReview ?? false;
 		this.curatorProvider = config.curatorProvider ?? "deepseek-official";
 		this.qualityWarnStaleAfterDays = config.qualityWarnStaleAfterDays ?? 7;
-		this.minIdleHours = config.minIdleHours ?? 0;
+		this.minIdleHours = config.minIdleHours ?? DEFAULT_MIN_IDLE_HOURS;
 		this.excludeSkillNames = new Set(config.excludeSkillNames ?? []);
 		this.manageUnmanaged = config.manageUnmanaged ?? false;
+		this.pruneBuiltins = config.pruneBuiltins ?? false;
+		this.referencedSkillNames = new Set(config.referencedSkillNames ?? []);
+		this.bootGraceSeconds = config.bootGraceSeconds ?? 10;
 		this.curatorReviewMaxTokens = config.curatorReviewMaxTokens ?? 2048;
 		this.lastRun = Date.now();
 		this.ctx.effect(() => {
@@ -60,6 +82,7 @@ var EvolutionCurator = class extends Service {
 				this.stop();
 			};
 		}, "evolution-curator.stop");
+		if (config.autoStart ?? true) this.start();
 	}
 	lifecycle() {
 		const snapshot = this.ctx.get("evolutionPolicy")?.get();
@@ -71,33 +94,54 @@ var EvolutionCurator = class extends Service {
 	}
 	start() {
 		if (!this.enabled || this.timer) return;
-		this.timer = setInterval(() => {
-			if (Date.now() - this.lastRun >= this.lifecycle().intervalHours * 36e5) this.run();
-		}, 3600 * 1e3);
+		this.bootCheck = setTimeout(() => {
+			this.bootCheck = void 0;
+			this.autoCheck();
+		}, this.bootGraceSeconds * 1e3);
+		this.bootCheck.unref();
+		this.timer = setInterval(() => void this.autoCheck(), 3600 * 1e3);
 		this.timer.unref();
 	}
 	stop() {
 		if (this.timer) clearInterval(this.timer);
 		this.timer = void 0;
+		if (this.bootCheck) clearTimeout(this.bootCheck);
+		this.bootCheck = void 0;
 	}
 	/**
-	* Optional Hermes-curator LLM pass. The model may only NOMINATE pruning
-	* candidates; archive/restore remains a control-plane operation and every
-	* nominated name is still checked against lifecycle thresholds and
-	* protected markers before any file move.
+	* One automatic schedule check: run a pass when the persisted curator state
+	* (falling back to the in-memory clock for state-less compositions) is at
+	* least one interval old. All gates — interval, idle, first-run defer,
+	* reentrancy — stay inside `run()`, so this method only decides whether to
+	* wake it, and never duplicates gate logic.
 	*/
-	async recommend(candidates) {
-		if (candidates.length === 0) return [];
+	async autoCheck() {
+		const last = (await this.curatorStateService()?.loadCuratorState())?.lastRunAt ?? this.lastRun;
+		if (Date.now() - last >= this.lifecycle().intervalHours * 36e5) await this.run();
+	}
+	/**
+	* Optional Hermes-curator LLM pass. The model may only NOMINATE pruning and
+	* consolidation; every move stays a control-plane operation and each
+	* nomination is re-validated against the tree and protected markers before
+	* any file move. `dryRun` prepends the report-only banner.
+	*/
+	async recommend(candidates, options = {}) {
+		const empty = {
+			prunings: [],
+			consolidations: []
+		};
+		if (candidates.length === 0) return empty;
 		const llm = this.ctx.get("llm");
-		if (!llm) return [];
+		if (!llm) return empty;
 		const model = this.ctx.get("evolutionPolicy")?.get().curatorModel ?? "deepseek-v4-pro";
 		const prompt = [
+			options.dryRun ? CURATOR_DRY_RUN_BANNER : "",
 			CURATOR_PROMPT,
 			"",
-			"Stale candidates observed by the deterministic lifecycle scanner:",
+			`Stale candidates observed by the deterministic lifecycle scanner:${candidates.length === 0 ? " (none)" : ""}`,
 			...candidates.map((name) => `- ${name}`),
 			"",
-			"Return a YAML summary with a prunings list. Nominate only candidates whose archival is clearly safe."
+			"Return a YAML summary with consolidations and prunings lists. Nominate only actions whose archival/merge is clearly safe."
 		].join("\n");
 		try {
 			const assembler = new BlockAssembler();
@@ -119,15 +163,56 @@ var EvolutionCurator = class extends Service {
 				maxTokens: this.curatorReviewMaxTokens,
 				purpose: "evolution-curator"
 			})) assembler.push(chunk);
-			const text = assembler.blocks().filter((block) => block.type === "text").map((block) => block.text).join("\n");
-			const names = /* @__PURE__ */ new Set();
-			const section = text.slice(text.indexOf("prunings:"));
-			for (const [, name] of section.matchAll(/^\s*-\s*name:\s*([a-z0-9][a-z0-9-]*)\s*$/gm)) if (name) names.add(name);
-			return [...names].filter((name) => candidates.includes(name));
+			const parsed = parseCuratorNominations(assembler.blocks().filter((block) => block.type === "text").map((block) => block.text).join("\n"));
+			return {
+				prunings: parsed.prunings.filter((name) => candidates.includes(name)),
+				consolidations: parsed.consolidations
+			};
 		} catch {
-			return [];
+			return empty;
 		}
 	}
+	/** Optional curator-state service (evolution-state-json / storage-domain). */
+	curatorStateService() {
+		return this.ctx.get("evolutionState");
+	}
+	/**
+	* Full-state snapshot: the skills tree plus the current curator state as an
+	* `extras/curator-state.json` side file. Every pre-mutation snapshot in the
+	* curator goes through here so a later `restoreSnapshot()` can rewind both
+	* the tree and the state (Hermes curator_backup backs up `.curator_state`).
+	*/
+	async snapshotFull(reason = "pre-mutation") {
+		const state = await this.curatorStateService()?.loadCuratorState();
+		const extras = state === null || state === void 0 ? [] : [{
+			name: "curator-state.json",
+			content: JSON.stringify(state, null, 2)
+		}];
+		return await this.skills.snapshotAll(reason, extras);
+	}
+	/**
+	* Full-state rollback: restore the latest snapshot's tree/sidecars/archive
+	* AND the curator state it carried. The pre-rollback safety snapshot keeps
+	* the current tree plus current state (as extras), so the rollback itself
+	* is reversible.
+	*/
+	async restoreSnapshot() {
+		const stateService = this.curatorStateService();
+		const currentState = await stateService?.loadCuratorState();
+		const extras = currentState === null || currentState === void 0 ? [] : [{
+			name: "curator-state.json",
+			content: JSON.stringify(currentState, null, 2)
+		}];
+		const result = await this.skills.restoreLatestSnapshot(extras);
+		if (!result.ok) return result;
+		const stateExtra = result.extras?.find((extra) => extra.name === "curator-state.json");
+		if (stateExtra && stateService) try {
+			await stateService.saveCuratorState(JSON.parse(stateExtra.content));
+		} catch (error) {
+			this.ctx.logger.warn(`evolution-curator: failed to restore curator state: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return result;
+	}
 	skippedReport(runId, startedAt) {
 		return buildCuratorRunReport({
 			runId,
@@ -137,57 +222,114 @@ var EvolutionCurator = class extends Service {
 			llmNominations: [],
 			archiveCandidates: [],
 			archived: [],
-			failed: []
+			failed: [],
+			llmReviewEnabled: this.llmReview
 		});
 	}
-	async run() {
+	/**
+	* Run one curator pass. `ignoreGates` skips the interval and idle gates so an
+	* explicit `/evolution curator run` always executes (manual-run semantics):
+	* `dryRun` computes the lifecycle and the LLM nominations but performs no
+	* mutation, reports what WOULD happen, and does not push out the next run.
+	* Reentrant calls (autoStart timer + manual command at the same instant) are
+	* skipped with an explicit `already-running` outcome.
+	*/
+	async run(options = {}) {
+		if (this.running) return {
+			stale: [],
+			archived: [],
+			errors: [],
+			report: this.skippedReport("already-running", (/* @__PURE__ */ new Date()).toISOString()),
+			skipped: "already-running"
+		};
+		this.running = true;
+		try {
+			return await this.runCore(options);
+		} finally {
+			this.running = false;
+		}
+	}
+	async runCore(options = {}) {
+		const { ignoreGates = false, dryRun = false } = options;
 		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 		const runId = randomUUID();
-		const stateService = this.ctx.get("evolutionState");
+		const stateService = this.curatorStateService();
 		const lifecycle = this.lifecycle();
 		const persisted = await stateService?.loadCuratorState();
-		if (persisted && Date.now() - persisted.lastRunAt < lifecycle.intervalHours * 36e5) return {
+		if (!ignoreGates && persisted && Date.now() - persisted.lastRunAt < lifecycle.intervalHours * 36e5) return {
 			stale: [],
 			archived: [],
 			errors: [],
 			report: this.skippedReport(runId, startedAt),
 			skipped: "interval"
 		};
-		if (this.minIdleHours > 0 && this.recentSessionActive()) return {
+		if (!ignoreGates && this.minIdleHours > 0 && this.recentSessionActive()) return {
 			stale: [],
 			archived: [],
 			errors: [],
 			report: this.skippedReport(runId, startedAt),
 			skipped: "active-session"
 		};
+		if (!ignoreGates && persisted === null) {
+			await stateService?.saveCuratorState({
+				schemaVersion: 1,
+				lastRunAt: Date.now(),
+				runCount: 0,
+				lastSummary: "first-run-deferred",
+				paused: false
+			});
+			return {
+				stale: [],
+				archived: [],
+				errors: [],
+				report: this.skippedReport(runId, startedAt),
+				skipped: "first-run-deferred"
+			};
+		}
 		const root = this.skills.root;
-		const snapshotPath = await this.skills.snapshotAll("pre-curator-run");
-		const usage = await loadUsage(root, this.io);
+		const rawUsage = await loadUsage(root, this.io);
+		const usage = dryRun ? new Map([...rawUsage].map(([name, record]) => [name, { ...record }])) : rawUsage;
+		const snapshotPath = dryRun ? void 0 : await this.snapshotFull("pre-curator-run");
+		const suppressedNames = new Set(await loadSuppressedNames(root, this.io));
+		const { bundledNames, treeNames } = await this.seedBaseline(usage);
 		const result = computeLifecycleTransitions(usage, {
 			staleAfterDays: lifecycle.staleAfterDays,
 			archiveAfterDays: lifecycle.archiveAfterDays,
 			qualityWarnStaleAfterDays: this.qualityWarnStaleAfterDays,
 			excludeSkillNames: this.excludeSkillNames,
-			manageUnmanaged: this.manageUnmanaged
+			manageUnmanaged: this.manageUnmanaged,
+			pruneBuiltins: this.pruneBuiltins,
+			bundledNames,
+			suppressedNames,
+			referencedSkillNames: this.referencedSkillNames
 		});
-		const errors = [];
-		const archivedSkills = [];
-		const llmNominations = this.llmReview ? await this.recommend(result.markStale) : [];
+		await this.scoreTree(usage, treeNames);
+		const nominations = this.llmReview ? await this.recommend(result.markStale, { dryRun }) : {
+			prunings: [],
+			consolidations: []
+		};
+		const gatedNominations = {
+			...nominations,
+			consolidations: gateConsolidations(nominations.consolidations, {
+				exclude: this.excludeSkillNames,
+				referenced: this.referencedSkillNames,
+				suppressed: suppressedNames
+			})
+		};
+		const llmNominations = gatedNominations.prunings;
 		const archiveCandidates = [...new Set([...result.archive, ...llmNominations])];
-		for (const name of archiveCandidates) {
-			const archived = await this.skills.archive(name, "Lifecycle: reached archive threshold");
-			if (!archived.ok) {
-				const record = usage.get(name);
-				if (record) record.state = "active";
-				errors.push(`${name}: ${archived.message}`);
-			} else archivedSkills.push({
-				name,
-				path: archived.path ?? "",
-				reason: "Lifecycle: reached archive threshold"
-			});
-		}
-		await saveUsage(root, usage, this.io);
-		this.lastRun = Date.now();
+		const { archivedSkills, errors } = await this.applyMutations({
+			dryRun,
+			archiveCandidates,
+			nominations: gatedNominations,
+			treeNames,
+			usage,
+			bundledNames,
+			suppressedNames,
+			root,
+			failedFrom: new Map(result.transitions.filter((t) => t.to === "archived").map((t) => [t.name, t.from]))
+		});
+		if (!dryRun) this.lastRun = Date.now();
 		const report = buildCuratorRunReport({
 			runId,
 			startedAt,
@@ -196,13 +338,14 @@ var EvolutionCurator = class extends Service {
 			llmNominations,
 			archiveCandidates,
 			archived: archivedSkills,
-			failed: archiveCandidates.filter((name) => errors.some((error) => error.startsWith(`${name}:`))).map((name) => {
+			failed: [...new Set([...archiveCandidates, ...gatedNominations.consolidations.map((item) => item.from)])].filter((name) => errors.some((error) => error.startsWith(`${name}:`))).map((name) => {
 				return {
 					name,
 					reason: errors.find((item) => item.startsWith(`${name}:`))?.slice(name.length + 2) ?? "unknown"
 				};
 			}),
-			snapshotPath
+			...snapshotPath === void 0 ? {} : { snapshotPath },
+			llmReviewEnabled: this.llmReview
 		});
 		const reportsRoot = join(evolutionHome(), "reports");
 		try {
@@ -211,17 +354,169 @@ var EvolutionCurator = class extends Service {
 			this.ctx.logger.warn(`evolution-curator: failed to persist report ${runId}`);
 			this.ctx.logger.warn(error);
 		}
+		const llmHint = !this.llmReview && result.markStale.length > 0 ? " (llmReview: off - deterministic archive only; set llmReview: true for the LLM merge channel)" : "";
+		const summary = `${dryRun ? "dry-run" : "auto"}: stale:${result.markStale.length} archived:${archivedSkills.length} consolidated:${gatedNominations.consolidations.length}${llmHint}`;
 		await stateService?.saveCuratorState({
-			lastRunAt: this.lastRun,
-			runCount: (persisted?.runCount ?? 0) + 1,
-			lastSummary: `stale:${result.markStale.length} archived:${archivedSkills.length}`,
+			schemaVersion: 1,
+			lastRunAt: dryRun ? persisted?.lastRunAt ?? this.lastRun : this.lastRun,
+			runCount: dryRun ? persisted?.runCount ?? 0 : (persisted?.runCount ?? 0) + 1,
+			lastSummary: summary,
 			paused: false
 		});
 		return {
 			stale: result.markStale,
 			archived: archivedSkills.map((item) => item.name),
 			errors,
-			report
+			report,
+			...this.llmReview ? { nominations: gatedNominations } : {}
+		};
+	}
+	/**
+	* Seed baseline records for tree skills the sidecar has not seen yet, so
+	* their inactivity clock starts now (first-sight defer) and bundled skills
+	* become known candidates only when prune-builtins opts them in. Also
+	* returns the full active tree names for nomination validation.
+	*/
+	async seedBaseline(usage) {
+		const bundledNames = /* @__PURE__ */ new Set();
+		const treeNames = /* @__PURE__ */ new Set();
+		for (const summary of await this.skills.list()) {
+			treeNames.add(summary.name);
+			if (!usage.has(summary.name)) usage.set(summary.name, emptyRecord());
+			if (await this.skills.isBundled(summary.name)) bundledNames.add(summary.name);
+			const record = usage.get(summary.name);
+			if (record) record.pinned = await this.skills.isPinned(summary.name);
+		}
+		return {
+			bundledNames,
+			treeNames
+		};
+	}
+	/**
+	* F13 six-factor quality scoring, persisted onto the usage records.
+	*/
+	async scoreTree(usage, treeNames) {
+		const supportDirs = /* @__PURE__ */ new Map();
+		for (const name of treeNames) supportDirs.set(name, await this.skills.countSupportDirs(name));
+		const quality = computeQualityScores({
+			usage,
+			supportDirs,
+			referenceCounts: await this.referenceCounts(treeNames)
+		});
+		for (const [name, score] of quality) {
+			const record = usage.get(name);
+			if (record) {
+				record.quality_score = score.score;
+				record.quality_warn = score.warn;
+			}
+		}
+	}
+	/**
+	* In-degree over explicit `related_skills` frontmatter references (the DSH
+	* equivalent of the graph-in-degree references factor): a skill listing
+	* other skill names counts as one reference to each of them, so hub skills
+	* that are explicitly named by peers get a non-zero references factor.
+	*/
+	async referenceCounts(treeNames) {
+		const counts = /* @__PURE__ */ new Map();
+		for (const name of treeNames) {
+			const content = await this.skills.read(name);
+			if (!content) continue;
+			const parsed = parseFrontmatter(content);
+			if (!parsed) continue;
+			const raw = parsed.frontmatter["related_skills"];
+			if (typeof raw !== "string") continue;
+			for (const match of Array.from(raw.matchAll(/[a-z0-9][a-z0-9-]*/g))) {
+				const target = match[0];
+				if (target && SKILL_NAME_RE.test(target) && target !== name) counts.set(target, (counts.get(target) ?? 0) + 1);
+			}
+		}
+		return counts;
+	}
+	/**
+	* Execute lifecycle archives and consolidation nominations, then persist the
+	* suppression and usage sidecars best-effort. A dry-run short-circuits: no
+	* file moves and no state persistence — the caller still writes the report.
+	*/
+	async applyMutations(input) {
+		if (input.dryRun) return {
+			archivedSkills: [],
+			errors: [],
+			suppressedChanged: false
+		};
+		const { archiveCandidates, nominations, treeNames, usage, bundledNames, suppressedNames, root, failedFrom } = input;
+		const errors = [];
+		const archivedSkills = [];
+		let suppressedChanged = false;
+		for (const name of archiveCandidates) {
+			const archived = await this.skills.archive(name, {
+				reason: "Lifecycle: reached archive threshold",
+				allowBundled: this.pruneBuiltins
+			});
+			if (!archived.ok) {
+				const record = usage.get(name);
+				const from = failedFrom?.get(name);
+				if (record && (from === "stale" || from === "active")) record.state = from;
+				errors.push(`${name}: ${archived.message}`);
+			} else {
+				const record = usage.get(name);
+				if (record) {
+					record.state = "archived";
+					record.archived_at = (/* @__PURE__ */ new Date()).toISOString();
+				}
+				archivedSkills.push({
+					name,
+					path: archived.path ?? "",
+					reason: "Lifecycle: reached archive threshold"
+				});
+				if (bundledNames.has(name)) {
+					suppressedNames.add(name);
+					suppressedChanged = true;
+				}
+			}
+		}
+		const alreadyArchived = new Set(archiveCandidates);
+		for (const nomination of nominations.consolidations) {
+			if (alreadyArchived.has(nomination.from)) continue;
+			if (!treeNames.has(nomination.from) || !treeNames.has(nomination.into)) {
+				errors.push(`${nomination.from}: consolidation target or source missing from the skill tree`);
+				continue;
+			}
+			const consolidated = await this.skills.consolidate(nomination.into, [nomination.from], "background_review");
+			if (!consolidated.ok) {
+				errors.push(`${nomination.from}: ${consolidated.message}`);
+				continue;
+			}
+			const record = usage.get(nomination.from);
+			if (record) {
+				record.state = "archived";
+				record.archived_at = (/* @__PURE__ */ new Date()).toISOString();
+			}
+			alreadyArchived.add(nomination.from);
+			archivedSkills.push({
+				name: nomination.from,
+				path: join(this.skills.root, ".archive", nomination.from),
+				reason: `Consolidated into ${nomination.into}`
+			});
+		}
+		if (suppressedChanged) try {
+			await saveSuppressedNames(root, suppressedNames, this.io);
+		} catch {
+			this.ctx.logger.warn("evolution-curator: failed to persist suppressed names; archived built-ins may re-enter the lifecycle");
+		}
+		try {
+			await saveUsage(root, usage, this.io);
+		} catch {
+			this.ctx.logger.warn("evolution-curator: failed to persist usage sidecar");
+		}
+		const usageRegistry = this.ctx.get("skillUsage");
+		try {
+			await usageRegistry?.invalidate?.();
+		} catch {}
+		return {
+			archivedSkills,
+			errors,
+			suppressedChanged
 		};
 	}
 	recentSessionActive() {
@@ -247,6 +542,77 @@ var EvolutionCurator = class extends Service {
 			return null;
 		}
 	}
+	/**
+	* Read-only lifecycle scope classification: which skills are in scope,
+	* watched (stale/quality-warned), exempted, or protected. Uses the same
+	* candidate gate as `run()` (`computeScopeView` / `lifecycleCandidate`),
+	* so the view always predicts what a curator pass may touch.
+	*/
+	async scopeView() {
+		const root = this.skills.root;
+		const usage = await loadUsage(root, this.io);
+		const { bundledNames } = await this.seedBaseline(usage);
+		return computeScopeView(usage, {
+			staleAfterDays: this.lifecycle().staleAfterDays,
+			archiveAfterDays: this.lifecycle().archiveAfterDays,
+			excludeSkillNames: this.excludeSkillNames,
+			referencedSkillNames: this.referencedSkillNames,
+			suppressedNames: new Set(await loadSuppressedNames(root, this.io)),
+			manageUnmanaged: this.manageUnmanaged,
+			pruneBuiltins: this.pruneBuiltins,
+			bundledNames
+		}, await this.protectedNameMap());
+	}
+	/** marker info (pinned/bundled/hub-installed) per skill, from the library list. */
+	async protectedNameMap() {
+		const map = /* @__PURE__ */ new Map();
+		for (const summary of await this.skills.list()) if (summary.protectedBy !== null) map.set(summary.name, summary.protectedBy);
+		return map;
+	}
+	/**
+	* Control-plane consolidation: merge source skill bodies into `target`,
+	* archive the sources with an absorbed-into marker, and fold their usage
+	* records into `archived` state. Snapshot-then-mutate, never a hard delete.
+	*/
+	async consolidate(target, sources) {
+		const blocked = [...this.excludeSkillNames].filter((name) => name === target || sources.includes(name));
+		if (blocked.length > 0) return {
+			ok: false,
+			message: `Skill(s) excluded from lifecycle management: ${blocked.join(", ")}`
+		};
+		await this.snapshotFull("pre-consolidate");
+		const result = await this.skills.consolidate(target, sources);
+		if (!result.ok) return result;
+		const usage = await loadUsage(this.skills.root, this.io);
+		for (const source of sources) {
+			const record = usage.get(source);
+			if (record) record.state = "archived";
+			if (record) record.archived_at = (/* @__PURE__ */ new Date()).toISOString();
+		}
+		await saveUsage(this.skills.root, usage, this.io);
+		return result;
+	}
+	/**
+	* Control-plane restore: bring one archived skill back to the active root
+	* and reset its usage state, keeping the recoverable-archive invariant.
+	*/
+	async restore(name) {
+		await this.snapshotFull("pre-restore");
+		const result = await this.skills.restoreFromArchive(name);
+		if (!result.ok) return result;
+		const usage = await loadUsage(this.skills.root, this.io);
+		const record = usage.get(name);
+		if (record) record.state = "active";
+		if (record) record.archived_at = null;
+		await saveUsage(this.skills.root, usage, this.io);
+		const suppressed = new Set(await loadSuppressedNames(this.skills.root, this.io));
+		if (suppressed.delete(name)) try {
+			await saveSuppressedNames(this.skills.root, suppressed, this.io);
+		} catch {
+			this.ctx.logger.warn(`evolution-curator: failed to persist suppressed names after restoring ${name}`);
+		}
+		return result;
+	}
 };
 //#endregion
-export { EvolutionCurator, EvolutionCurator as default };
+export { EvolutionCurator, EvolutionCurator as default, gateConsolidations };

package/lib/types/index.d.ts

@@ -5,7 +5,7 @@
 import { Context, Service } from '@deepseek-ai/cordis';
 import type Schema from '@deepseek-ai/schemastery';
 import { SkillLibrary } from '@deepseek-ai/dsh-evolution-core';
-import { type CuratorRunReport } from '@deepseek-ai/dsh-evolution-core';
+import { type CuratorConsolidation, type CuratorNominations, type CuratorRunReport, type ScopeView, type SkillActionResult } from '@deepseek-ai/dsh-evolution-core';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         evolutionCurator: EvolutionCurator;
@@ -27,9 +27,46 @@ export interface Config {
     excludeSkillNames?: string[];
     /** Include usage records whose created_by is not 'agent' in lifecycle decisions. */
     manageUnmanaged?: boolean;
+    /** Archive long-unused bundled skills too (with suppression against re-seeds). */
+    pruneBuiltins?: boolean;
+    /** Static scheduled-task skill references; such skills never auto-transition. */
+    referencedSkillNames?: string[];
+    /** Start the interval timer on context ready (auto-curation). Default true. */
+    autoStart?: boolean;
+    /** Seconds between host boot and the first automatic schedule check (restart catch-up). */
+    bootGraceSeconds?: number;
     /** Max tokens for the optional LLM nomination pass. */
     curatorReviewMaxTokens?: number;
 }
+/** Outcome of one curator run pass. */
+export interface CuratorRunOutcome {
+    stale: string[];
+    archived: string[];
+    errors: string[];
+    report: CuratorRunReport;
+    skipped?: string;
+    /** LLM nominations when the optional review pass is enabled (audit visibility). */
+    nominations?: CuratorNominations;
+}
+/** Persisted curator-state record shape (schemaVersion optional for legacy reads). */
+export interface CuratorStateRecordShape {
+    schemaVersion?: number;
+    lastRunAt: number;
+    runCount: number;
+    lastSummary: string;
+    paused: boolean;
+}
+/**
+ * Block LLM-nominated consolidations that would touch a gate-protected name:
+ * exclude / referenced / suppressed skills must never merge (neither as the
+ * source being archived nor as the umbrella being edited). Mirrors the control
+ * plane's `consolidate()` guard; automatic nominations must pass the same gate.
+ */
+export declare function gateConsolidations(consolidations: CuratorConsolidation[], gates: {
+    exclude?: ReadonlySet<string>;
+    referenced?: ReadonlySet<string>;
+    suppressed?: ReadonlySet<string>;
+}): CuratorConsolidation[];
 export declare class EvolutionCurator extends Service {
     static inject: string[];
     static Config: Schema<Config>;
@@ -45,30 +82,116 @@ export declare class EvolutionCurator extends Service {
     private readonly minIdleHours;
     private readonly excludeSkillNames;
     private readonly manageUnmanaged;
+    private readonly pruneBuiltins;
+    private readonly referencedSkillNames;
+    private readonly bootGraceSeconds;
     private readonly curatorReviewMaxTokens;
     private lastRun;
     private timer;
+    private bootCheck;
+    private running;
     constructor(ctx: Context, config?: Config);
     private lifecycle;
     start(): void;
     stop(): void;
     /**
-     * Optional Hermes-curator LLM pass. The model may only NOMINATE pruning
-     * candidates; archive/restore remains a control-plane operation and every
-     * nominated name is still checked against lifecycle thresholds and
-     * protected markers before any file move.
+     * One automatic schedule check: run a pass when the persisted curator state
+     * (falling back to the in-memory clock for state-less compositions) is at
+     * least one interval old. All gates — interval, idle, first-run defer,
+     * reentrancy — stay inside `run()`, so this method only decides whether to
+     * wake it, and never duplicates gate logic.
      */
-    recommend(candidates: string[]): Promise<string[]>;
-    private skippedReport;
-    run(): Promise<{
-        stale: string[];
-        archived: string[];
-        errors: string[];
-        report: CuratorRunReport;
-        skipped?: string;
+    private autoCheck;
+    /**
+     * Optional Hermes-curator LLM pass. The model may only NOMINATE pruning and
+     * consolidation; every move stays a control-plane operation and each
+     * nomination is re-validated against the tree and protected markers before
+     * any file move. `dryRun` prepends the report-only banner.
+     */
+    recommend(candidates: string[], options?: {
+        dryRun?: boolean;
+    }): Promise<CuratorNominations>;
+    /** Optional curator-state service (evolution-state-json / storage-domain). */
+    private curatorStateService;
+    /**
+     * Full-state snapshot: the skills tree plus the current curator state as an
+     * `extras/curator-state.json` side file. Every pre-mutation snapshot in the
+     * curator goes through here so a later `restoreSnapshot()` can rewind both
+     * the tree and the state (Hermes curator_backup backs up `.curator_state`).
+     */
+    snapshotFull(reason?: string): Promise<string>;
+    /**
+     * Full-state rollback: restore the latest snapshot's tree/sidecars/archive
+     * AND the curator state it carried. The pre-rollback safety snapshot keeps
+     * the current tree plus current state (as extras), so the rollback itself
+     * is reversible.
+     */
+    restoreSnapshot(): Promise<SkillActionResult & {
+        extras?: Array<{
+            name: string;
+            content: string;
+        }>;
     }>;
+    private skippedReport;
+    /**
+     * Run one curator pass. `ignoreGates` skips the interval and idle gates so an
+     * explicit `/evolution curator run` always executes (manual-run semantics):
+     * `dryRun` computes the lifecycle and the LLM nominations but performs no
+     * mutation, reports what WOULD happen, and does not push out the next run.
+     * Reentrant calls (autoStart timer + manual command at the same instant) are
+     * skipped with an explicit `already-running` outcome.
+     */
+    run(options?: {
+        ignoreGates?: boolean;
+        dryRun?: boolean;
+    }): Promise<CuratorRunOutcome>;
+    private runCore;
+    /**
+     * Seed baseline records for tree skills the sidecar has not seen yet, so
+     * their inactivity clock starts now (first-sight defer) and bundled skills
+     * become known candidates only when prune-builtins opts them in. Also
+     * returns the full active tree names for nomination validation.
+     */
+    private seedBaseline;
+    /**
+     * F13 six-factor quality scoring, persisted onto the usage records.
+     */
+    private scoreTree;
+    /**
+     * In-degree over explicit `related_skills` frontmatter references (the DSH
+     * equivalent of the graph-in-degree references factor): a skill listing
+     * other skill names counts as one reference to each of them, so hub skills
+     * that are explicitly named by peers get a non-zero references factor.
+     */
+    private referenceCounts;
+    /**
+     * Execute lifecycle archives and consolidation nominations, then persist the
+     * suppression and usage sidecars best-effort. A dry-run short-circuits: no
+     * file moves and no state persistence — the caller still writes the report.
+     */
+    private applyMutations;
     private recentSessionActive;
     latestReport(): Promise<CuratorRunReport | null>;
+    /**
+     * Read-only lifecycle scope classification: which skills are in scope,
+     * watched (stale/quality-warned), exempted, or protected. Uses the same
+     * candidate gate as `run()` (`computeScopeView` / `lifecycleCandidate`),
+     * so the view always predicts what a curator pass may touch.
+     */
+    scopeView(): Promise<ScopeView>;
+    /** marker info (pinned/bundled/hub-installed) per skill, from the library list. */
+    private protectedNameMap;
+    /**
+     * Control-plane consolidation: merge source skill bodies into `target`,
+     * archive the sources with an absorbed-into marker, and fold their usage
+     * records into `archived` state. Snapshot-then-mutate, never a hard delete.
+     */
+    consolidate(target: string, sources: string[]): Promise<SkillActionResult>;
+    /**
+     * Control-plane restore: bring one archived skill back to the active root
+     * and reset its usage state, keeping the recoverable-archive invariant.
+     */
+    restore(name: string): Promise<SkillActionResult>;
 }
 export default EvolutionCurator;
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-curator",
   "description": "Deterministic skill lifecycle and recovery (community build)",
-  "version": "0.1.0-rc.4",
+  "version": "0.1.0-rc.40",
   "publishConfig": {
     "access": "public"
   },
@@ -33,20 +33,20 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1",
-    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.4"
+    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.40"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.4",
-    "@lmzhen/dsh-evolution-state": "^0.1.0-rc.4"
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.40",
+    "@lmzhen/dsh-evolution-state": "^0.1.0-rc.40"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.4",
-    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.4",
-    "@lmzhen/dsh-evolution-state": "^0.1.0-rc.4"
+    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.40",
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.40",
+    "@lmzhen/dsh-evolution-state": "^0.1.0-rc.40"
   }
 }