@lmzhen/dsh-evolution-core 0.3.62 → 0.3.63

package/lib/index.js

@@ -534,7 +534,9 @@ function normalizeUsageRecord(record) {
 		pinned: bool(raw.pinned, base.pinned),
 		archived_at: nullableTimestamp(raw.archived_at) ? raw.archived_at : base.archived_at,
 		quality_score: typeof raw.quality_score === "number" && Number.isFinite(raw.quality_score) ? raw.quality_score : void 0,
-		quality_warn: typeof raw.quality_warn === "boolean" ? raw.quality_warn : void 0
+		quality_warn: typeof raw.quality_warn === "boolean" ? raw.quality_warn : void 0,
+		feedback_score: typeof raw.feedback_score === "number" && Number.isFinite(raw.feedback_score) ? raw.feedback_score : void 0,
+		feedback_warn: typeof raw.feedback_warn === "boolean" ? raw.feedback_warn : void 0
 	};
 }
 /** Parse a raw usage sidecar; malformed content reads as empty (best-effort telemetry). */
@@ -560,11 +562,14 @@ async function loadUsage(root, io = nodeEvolutionIo()) {
 */
 async function mutateUsage(root, io, task) {
 	await transactIo(io, usageFile(root), async (current) => {
+		let shapePreserved = false;
 		if (current !== null) try {
-			JSON.parse(current);
+			const probe = JSON.parse(current);
+			if (probe === null || Array.isArray(probe) || typeof probe !== "object") shapePreserved = true;
 		} catch {
 			return current;
 		}
+		if (shapePreserved) return current;
 		const map = parseUsage(current);
 		await task(map);
 		return JSON.stringify(Object.fromEntries(map.entries()), null, 2);
@@ -593,6 +598,9 @@ function applyCuratorLifecycleFields(disk, curated) {
 * Copy the recomputed meta pair (quality_score/quality_warn + the
 * marker-mirrored pin flag) — refreshed tree-wide each run by design, so a
 * concurrent curator run's lifecycle changes are never reverted by them.
+* P1-1 (v15): the feedback pair (`feedback_score`/`feedback_warn`) is
+* deliberately NOT copied — it is feedback-owned (see the field-ownership
+* contract on {@link UsageRecord}) and must survive curator runs untouched.
 */
 function applyCuratorMetaFields(disk, curated) {
 	disk.quality_score = curated.quality_score;
@@ -1018,8 +1026,9 @@ function computeScopeView(usage, config, protectedNames, gates) {
 		if (record.pinned || bundled || suppressed || protectedNames?.has(name) === true || isBuiltin) protectedSet.add(name);
 		if (lifecycleCandidate(name, record, config, bundled, gateSet, protectedNames)) {
 			managed.push(name);
-			if (record.state === "stale" || record.quality_warn === true) watched.push(name);
-			if (record.quality_warn === true) qualityWarned.push(name);
+			const warned = record.quality_warn === true || record.feedback_warn === true;
+			if (record.state === "stale" || warned) watched.push(name);
+			if (warned) qualityWarned.push(name);
 		}
 	}
 	return {
@@ -1046,7 +1055,7 @@ function computeLifecycleTransitions(usage, config, now = /* @__PURE__ */ new Da
 		const age = daysSince(null, record.created_at, now.getTime());
 		if (record.use_count === 0 && age < config.staleAfterDays) continue;
 		const idle = daysSince(latestActivityAt(record), record.created_at, now.getTime());
-		const qualityWarn = record.quality_warn === true;
+		const qualityWarn = record.quality_warn === true || record.feedback_warn === true;
 		const staleAfterDays = qualityWarn && config.qualityWarnStaleAfterDays !== void 0 ? config.qualityWarnStaleAfterDays : config.staleAfterDays;
 		if (record.state === "active") {
 			if (idle >= config.archiveAfterDays) {
@@ -1061,7 +1070,8 @@ function computeLifecycleTransitions(usage, config, now = /* @__PURE__ */ new Da
 				result.archive.push(name);
 			} else if (idle >= staleAfterDays) {
 				record.state = "stale";
-				const reason = qualityWarn ? `idle ${Math.round(idle)}d >= quality-warn stale ${staleAfterDays}d` : `idle ${Math.round(idle)}d >= ${staleAfterDays}d`;
+				const warnSource = record.feedback_warn === true ? "feedback-warn stale" : "quality-warn stale";
+				const reason = qualityWarn ? `idle ${Math.round(idle)}d >= ${warnSource} ${staleAfterDays}d` : `idle ${Math.round(idle)}d >= ${staleAfterDays}d`;
 				result.transitions.push({
 					name,
 					from: "active",
@@ -2092,12 +2102,12 @@ function scanThreats(text, scope = "strict", maxScanChars = 65536, options = NO_
 	if (ZERO_WIDTH_CHARS.test(text) && !excluded.has("unicode_zero_width")) findings.push({
 		label: "unicode_zero_width",
 		category: "unicode_obfuscation",
-		scope
+		scope: "all"
 	});
 	if (BIDI_CHARS.test(text) && !excluded.has("unicode_bidi_override")) findings.push({
 		label: "unicode_bidi_override",
 		category: "unicode_obfuscation",
-		scope
+		scope: "all"
 	});
 	const normalized = text.normalize("NFKC");
 	const windows = [];
@@ -2397,7 +2407,13 @@ var MemoryStore = class {
 	async addCore(target, facts, raw) {
 		const content = facts.trim();
 		if (!content) return {
-			result: this.failure(target, "Content cannot be empty.", []),
+			result: {
+				ok: false,
+				message: "Content cannot be empty.",
+				entries: [],
+				chars: 0,
+				limit: this.limitFor(target)
+			},
 			write: null
 		};
 		if (this.driftFromRaw(target, raw)) {
@@ -2737,25 +2753,31 @@ function contentHash(content) {
 function parseMutationRecords(raw) {
 	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" && typeof entry.at === "string");
+		return recordsFromParsed(JSON.parse(raw));
 	} catch {
 		return [];
 	}
 }
+/** Field-level shape guard shared by the parse and the recordMutation write
+* path (P3/v15: the guard's JSON.parse and this parse used to run twice over
+* the same bytes inside one transact). */
+function recordsFromParsed(parsed) {
+	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" && typeof entry.at === "string");
+}
 async function loadMutations(root, io = nodeEvolutionIo()) {
 	return parseMutationRecords(await io.readText(mutationsFile(root)));
 }
 /** Append one record, trim to `cap`, and write atomically (versioned shape). */
 async function recordMutation(root, io, record, cap = 500) {
 	await transactIo(io, mutationsFile(root), (current) => {
+		let parsed = [];
 		if (current !== null) try {
-			JSON.parse(current);
+			parsed = JSON.parse(current);
 		} catch {
 			console.warn(`mutation audit record dropped: ${mutationsFile(root)} is malformed and was not overwritten`);
 			return current;
 		}
-		const existing = parseMutationRecords(current);
+		const existing = recordsFromParsed(parsed);
 		existing.push(record);
 		const trimmed = existing.length > cap ? existing.slice(existing.length - cap) : existing;
 		return JSON.stringify({
@@ -3693,7 +3715,9 @@ const SUPPORT_FILE_NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;
 /** C-18: win32 reserves these stems with ANY extension (`nul.md` hits the
 * NUL device), and they are fully inside the charset above — so the reserved
 * set is checked on the first-dot prefix as well; the charset close alone
-* cannot refuse them. */
+* cannot refuse them. Exported single source: `badName` (skill directories,
+* P2-11/v15) and `validateSupportPath` (support-file stems, C-18) both
+* consume this one set — a third copy would drift. */
 const WIN32_RESERVED_DEVICE_NAMES = new Set([
 	"con",
 	"prn",
@@ -3726,6 +3750,7 @@ function validateSupportPath(filePath) {
 	if (parts.length < 2) return "Provide a file name, not just a directory.";
 	for (const part of parts.slice(1)) {
 		if (!SUPPORT_FILE_NAME_RE.test(part)) return `Unsupported file name "${part}" — use lowercase letters, digits, dots, hyphens, and underscores (leading letter or digit).`;
+		if (part.toLowerCase().endsWith(".lock")) return `Unsupported file name "${part}" — the .lock suffix is reserved for the writer-lock protocol.`;
 		const stem = part.split(".")[0]?.toLowerCase() ?? "";
 		if (WIN32_RESERVED_DEVICE_NAMES.has(stem)) return `Unsupported file name "${part}" — a Windows reserved device name.`;
 	}
@@ -4023,9 +4048,10 @@ var SkillLibrary = class {
 	* are the deliberate exceptions — their names come from `listNames()`, i.e.
 	* from the tree itself, never from caller input.
 	*/
-	badName(name) {
+	badName(name, opts = {}) {
 		const normalized = name.trim();
 		if (!SKILL_NAME_RE.test(normalized) || normalized.length > this.limits.maxNameLength) return `Invalid skill name "${normalized}". Use lowercase letters, digits, and hyphens (<= ${this.limits.maxNameLength}).`;
+		if (!opts.allowReserved && WIN32_RESERVED_DEVICE_NAMES.has(normalized)) return `"${normalized}" is a Windows reserved device name and cannot be used as a skill name.`;
 		return null;
 	}
 	/**
@@ -4045,7 +4071,7 @@ var SkillLibrary = class {
 	}
 	async deleteProtection(rawName, options = {}) {
 		const name = rawName.trim();
-		const badName = this.badName(name);
+		const badName = this.badName(name, { allowReserved: true });
 		if (badName) return badName;
 		const dir = this.dirOf(name);
 		const markers = options.allowBundled ? ["hub-installed", "pinned"] : [
@@ -4247,7 +4273,21 @@ var SkillLibrary = class {
 			message: `Skill "${normalized}" is protected (${protection}).`
 		};
 		const onDisk = finalContent.trimEnd() + "\n";
-		await this.io.writeText(join(dir, "SKILL.md"), onDisk);
+		const createPath = join(dir, "SKILL.md");
+		let existsAtCommit = false;
+		if (this.transact) await this.transact(this.io, createPath, (current) => {
+			if (current !== null) {
+				existsAtCommit = true;
+				return current;
+			}
+			return onDisk;
+		});
+		else if (await this.io.exists(createPath)) existsAtCommit = true;
+		else await this.io.writeText(createPath, onDisk);
+		if (existsAtCommit) return {
+			ok: false,
+			message: `Skill "${normalized}" already exists.`
+		};
 		if (origin !== "foreground") await this.io.writeText(markerPath(dir, "hermes-managed"), "");
 		await this.audit(normalized, "create", null, onDisk, "created");
 		this.notifyMutation({
@@ -4267,13 +4307,13 @@ var SkillLibrary = class {
 		return await this.serial(() => this.updateCore(name, content, origin));
 	}
 	async updateCore(name, content, origin) {
-		const dir = this.dirOf(name);
-		const path = join(dir, "SKILL.md");
 		const badName = this.badName(name);
 		if (badName) return {
 			ok: false,
 			message: badName
 		};
+		const dir = this.dirOf(name);
+		const path = join(dir, "SKILL.md");
 		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
@@ -4493,9 +4533,113 @@ var SkillLibrary = class {
 			};
 		});
 	}
+	/**
+	* P2-9 (v15): the destructive directory move shared by archive and
+	* restoreFromArchive — rename first, copy+remove fallback when the backend
+	* cannot rename across media (V5-35), with the E-14 rollback when the
+	* fallback's source removal fails. Returns a failure MESSAGE on a failed
+	* move (caller wraps into a structured result) or undefined on success.
+	*/
+	async moveDir(dir, dest) {
+		try {
+			await this.io.rename(dir, dest);
+			return;
+		} catch {
+			if (await this.io.exists(dest)) return "the destination appeared mid-move (concurrent create or restore); refusing to merge — inspect both trees";
+			try {
+				await this.io.copy(dir, dest);
+			} catch (copyError) {
+				return `the move fell back to copy but failed (${copyError instanceof Error ? copyError.message : String(copyError)}); the tree stays where it is`;
+			}
+			try {
+				await this.io.remove(dir);
+				return;
+			} catch (error) {
+				const reason = error instanceof Error ? error.message : String(error);
+				try {
+					await this.io.remove(dest);
+					return `the copy succeeded but the source could not be removed (${reason}); the copied tree was rolled back`;
+				} catch {
+					return `the copy succeeded but the source could not be removed (${reason}) and the copied tree could not be rolled back — the tree now exists in BOTH locations; clean up manually`;
+				}
+			}
+		}
+	}
+	/**
+	* P2 (v16): the write-lock probe for the DESTRUCTIVE MOVERS (archive /
+	* restoreFromArchive). A byte-writer mid-flight is the ghost-generator —
+	* after the move its transact commit re-creates `<dir>/…` (mkdir
+	* recursive) and the tree ends half-archived. The signal is the writer's
+	* own lock file, and its PLACEMENT (inside the moved directory) is why the
+	* mover must PROBE-and-REFUSE instead of acquiring it: an acquired lock
+	* would be renamed into `.archive` with the tree, stranding a phantom live
+	* lock (the v16 audit proved the probe→rename TOCTOU does exactly that,
+	* and restore would later move the residue back into the live root).
+	* Coverage: `SKILL.md.lock` (update/patch of the body) plus one level of
+	* each support dir (write_file's lock sits next to its file). Residual:
+	* NESTED support-subdir locks and the probe→rename TOCTOU itself remain
+	* fail-safe (renameWithRetry rides the write out; the writer's locked
+	* re-read refuses on the moved-away file), and a residue `.lock` from a
+	* CRASHED writer also refuses — correct: inspect, don't archive.
+	*/
+	async hasWriteLock(dir) {
+		const markerLocks = [
+			join(dir, "SKILL.md.lock"),
+			join(dir, ".pinned.lock"),
+			join(dir, ".hermes-managed.lock")
+		];
+		for (const lock of markerLocks) if (await this.isWriterLock(lock)) return true;
+		for (const supportDir of SUPPORT_DIRS) {
+			let entries;
+			try {
+				entries = await this.io.list(join(dir, supportDir));
+			} catch {
+				return true;
+			}
+			for (const entry of entries) {
+				if (!entry.endsWith(".lock")) continue;
+				if (await this.isWriterLock(join(dir, supportDir, entry))) return true;
+			}
+		}
+		return false;
+	}
+	/** P2 (v17): a file only counts as a writer lock when its body has the
+	* `pid:token` shape the io layer writes. User support files legitimately
+	* named `*.lock` (allowed by SUPPORT_FILE_NAME_RE) must not trip the probe
+	* or be swept as residue — the v16 first cut matched on suffix alone,
+	* which permanently refused archiving and deleted user content on restore. */
+	async isWriterLock(lockPath) {
+		const body = await this.io.readText(lockPath).catch(() => null);
+		if (body === null) return false;
+		return /^\d+:[0-9a-f]*$/.test(body.trim());
+	}
+	/** P2 (v16): best-effort removal of lock residue inside a RESTORED tree —
+	* a `.lock` that a pre-restore crash or TOCTOU stranded in `.archive`
+	* cannot have a live writer (restore refuses when the live root is
+	* locked), and if left in place its body (a live pid on a single-host
+	* deployment) structurally closes the writer's self-heal path. */
+	async deleteStrandedLocks(dir) {
+		await this.sweepLockIfStranded(join(dir, "SKILL.md.lock"));
+		for (const supportDir of SUPPORT_DIRS) {
+			let entries = [];
+			try {
+				entries = await this.io.list(join(dir, supportDir));
+			} catch {
+				continue;
+			}
+			for (const entry of entries) if (entry.endsWith(".lock")) await this.sweepLockIfStranded(join(dir, supportDir, entry));
+		}
+	}
+	/** Remove `lockPath` only when its body has the writer-lock `pid:token`
+	* shape; anything else (a user support file) is left untouched. */
+	async sweepLockIfStranded(lockPath) {
+		const body = await this.io.readText(lockPath).catch(() => null);
+		if (body === null || !/^\d+:[0-9a-f]*$/.test(body.trim())) return;
+		await this.io.remove(lockPath).catch(() => {});
+	}
 	async archive(rawName, options = {}) {
 		const name = rawName.trim();
-		const badName = this.badName(name);
+		const badName = this.badName(name, { allowReserved: true });
 		if (badName) return {
 			ok: false,
 			message: badName
@@ -4516,6 +4660,11 @@ var SkillLibrary = class {
 				ok: false,
 				message: "absorbed_into cannot be the skill being archived (cannot absorb into itself)."
 			};
+			const intoBad = this.badName(options.absorbedInto.trim());
+			if (intoBad) return {
+				ok: false,
+				message: `absorbed_into: ${intoBad}`
+			};
 			if (!await this.io.readText(join(this.dirOf(options.absorbedInto), "SKILL.md"))) return {
 				ok: false,
 				message: `absorbed_into="${options.absorbedInto}" does not exist.`
@@ -4534,35 +4683,15 @@ var SkillLibrary = class {
 				message: `Skill "${name}" is a symlink; refusing to archive it.`
 			};
 		}
-		try {
-			await this.io.rename(dir, dest);
-		} catch {
-			try {
-				await this.io.copy(dir, dest);
-			} catch (copyError) {
-				return {
-					ok: false,
-					message: `Skill "${name}" archive fell back to copy but failed (${copyError instanceof Error ? copyError.message : String(copyError)}); the skill stays where it is.`
-				};
-			}
-			try {
-				await this.io.remove(dir);
-			} catch (error) {
-				const reason = error instanceof Error ? error.message : String(error);
-				try {
-					await this.io.remove(dest);
-					return {
-						ok: false,
-						message: `Archive copy succeeded but the source could not be removed (${reason}); the copied archive was rolled back.`
-					};
-				} catch {
-					return {
-						ok: false,
-						message: `Archive copy succeeded but the source could not be removed (${reason}) and the archive copy could not be rolled back — the skill now exists in BOTH the active root and .archive; clean up manually.`
-					};
-				}
-			}
-		}
+		if (await this.hasWriteLock(dir)) return {
+			ok: false,
+			message: `Skill "${name}" is being written (write lock present); retry archiving once the write completes.`
+		};
+		const moveFailure = await this.moveDir(dir, dest);
+		if (moveFailure !== void 0) return {
+			ok: false,
+			message: `Skill "${name}" archive failed: ${moveFailure}.`
+		};
 		const reason = options.reason ?? (options.absorbedInto ? `Consolidated into ${options.absorbedInto}` : "Archived by self-evolution curator");
 		try {
 			await this.io.writeText(join(dest, ".archive-reason"), `${(/* @__PURE__ */ new Date()).toISOString()}: ${reason}\n`);
@@ -4875,7 +5004,7 @@ var SkillLibrary = class {
 	*/
 	async applyTreeChange(plan) {
 		const name = plan.name.trim();
-		const badName = this.badName(name);
+		const badName = this.badName(name, { allowReserved: true });
 		if (badName) return {
 			ok: false,
 			message: badName
@@ -4959,7 +5088,7 @@ var SkillLibrary = class {
 	*/
 	async restoreFromArchive(rawName) {
 		const name = rawName.trim();
-		const bad = this.badName(name);
+		const bad = this.badName(name, { allowReserved: true });
 		if (bad) return {
 			ok: false,
 			message: bad
@@ -4996,20 +5125,18 @@ var SkillLibrary = class {
 				message: `Archived entry "${chosen}" is a symlink; refusing to restore it.`
 			};
 		}
-		try {
-			await this.io.rename(source, dest);
-		} catch {
-			try {
-				await this.io.copy(source, dest);
-				await this.io.remove(source);
-			} catch (error) {
-				return {
-					ok: false,
-					message: `Restore of "${name}" from .archive failed: ${error instanceof Error ? error.message : String(error)}`
-				};
-			}
-		}
+		if (await this.hasWriteLock(dest)) return {
+			ok: false,
+			message: `Skill "${name}" is being written (write lock present); retry restoring once the write completes.`
+		};
+		const moveFailure = await this.moveDir(source, dest);
+		if (moveFailure !== void 0) return {
+			ok: false,
+			message: `Restore of "${name}" from .archive failed: ${moveFailure}`
+		};
+		await this.deleteStrandedLocks(dest);
 		if (await this.io.exists(join(dest, ".archive-reason"))) await this.io.remove(join(dest, ".archive-reason"));
+		await this.audit(name, "restore", null, await this.io.readText(join(dest, "SKILL.md")).catch(() => null), `restored from ${source}`);
 		this.notifyMutation({
 			action: "restore",
 			name,
@@ -5026,12 +5153,12 @@ var SkillLibrary = class {
 		return await this.serial(() => this.writeSupportFileCore(name, filePath, content, origin));
 	}
 	async writeSupportFileCore(name, filePath, content, origin) {
-		const dir = this.dirOf(name);
 		const badName = this.badName(name);
 		if (badName) return {
 			ok: false,
 			message: badName
 		};
+		const dir = this.dirOf(name);
 		if (!await this.io.exists(join(dir, "SKILL.md"))) return {
 			ok: false,
 			message: `Skill "${name}" not found.`
@@ -5120,6 +5247,10 @@ var SkillLibrary = class {
 			message: `File "${filePath}" not found in skill "${name}".`
 		};
 		const before = await this.io.readText(target).catch(() => null);
+		if (before === null) return {
+			ok: false,
+			message: `"${filePath}" is not a readable regular file — remove the files inside it one by one.`
+		};
 		await this.io.remove(target);
 		await this.audit(name, "remove_file", before, null, `removed ${filePath}`);
 		this.notifyMutation({
@@ -5320,7 +5451,11 @@ var SkillLibrary = class {
 				await this.io.copy(join(snapshotPath, ".archive"), archiveRoot);
 			} else if (manifest.hasArchive === false) await this.io.remove(archiveRoot);
 		}
+		for (const entry of await this.io.list(this.root)) {
+			if (entry.startsWith(".")) continue;
+			await this.deleteStrandedLocks(join(this.root, entry));
+		}
 	}
 };
 //#endregion
-export { AUTHORING_DESCRIPTION_BAR, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_CURATOR_BOOT_GRACE_SECONDS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_CURATOR_REVIEW_MAX_TOKENS, DEFAULT_HEALTH_THRESHOLDS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_REVIEW_CONTEXT_MESSAGES, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_MESSAGE_CHARS, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_REVIEW_TIMEOUT_MS, 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, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_WRITE_TOOLS, EvolutionGateSet, FORBIDDEN_CONTROL_KEYS, HEALTH_STAMP_RE, LOW_QUALITY_THRESHOLD, MAINTAIN_OUTPUT_INSTRUCTION, MAINTAIN_PROMPT, MAX_DESCRIPTION_LENGTH, MAX_RESTRUCTURE_MOVES, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MEMORY_REVIEW_PROMPT, MIN_STAMP_BODY_CHARS, MUTATIONS_FILE_VERSION, MemoryStore, PATTERN_OVERLAP, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, QUALITY_WEIGHTS, RESTRUCTURE_TARGET_RE, SKILLS_GUIDANCE, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, THREAT_EXEMPT_HINT, advanceReview, allowRowCollisions, appendEvolutionEvent, applyCuratorFields, applyCuratorLifecycleFields, applyCuratorMetaFields, assessStructureHealth, authoringFeedback, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpUse, bumpView, clampedNumber, composePresetComposition, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, createGateSet, duplicateHeadings, emptyRecord, evaluateThreat, eventsFile, evolutionHome, evolutionIoAdapter, evolutionRoot, findDriftSignal, foldCuratorFields, foldTurn, frontmatterBlock, frontmatterYamlUnsafeValues, getRecord, latestActivityAt, lifecycleCandidate, listEventArchives, loadMutations, loadSuppressedNames, loadUsage, makeSerialQueue, markAgentCreated, markerEntryName, memoryRoot, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, observeEvent, overlongLines, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, pendingSelfCleanup, readEvolutionEvents, readEvolutionTimeline, recordMutation, redactSecrets, relatedSkillNames, renameWithRetry, renderCuratorReportMarkdown, resolveOrigins, resolveSkillsRoot, retainEventArchives, reviewPrompt, saveSuppressedNames, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, skillsRoot, suppressedFile, transactIo, updateSuppressedNames, usageFile, usageObserved, validateFrontmatter, verifyPromptBundle, writeDurableTmp, yamlPlainScalarNeedsQuotes };
+export { AUTHORING_DESCRIPTION_BAR, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_CURATOR_BOOT_GRACE_SECONDS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_CURATOR_REVIEW_MAX_TOKENS, DEFAULT_HEALTH_THRESHOLDS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_REVIEW_CONTEXT_MESSAGES, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_MESSAGE_CHARS, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_REVIEW_TIMEOUT_MS, 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, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_WRITE_TOOLS, EvolutionGateSet, FORBIDDEN_CONTROL_KEYS, HEALTH_STAMP_RE, LOW_QUALITY_THRESHOLD, MAINTAIN_OUTPUT_INSTRUCTION, MAINTAIN_PROMPT, MAX_DESCRIPTION_LENGTH, MAX_RESTRUCTURE_MOVES, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MEMORY_REVIEW_PROMPT, MIN_STAMP_BODY_CHARS, MUTATIONS_FILE_VERSION, MemoryStore, PATTERN_OVERLAP, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, QUALITY_WEIGHTS, RESTRUCTURE_TARGET_RE, SKILLS_GUIDANCE, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, THREAT_EXEMPT_HINT, WIN32_RESERVED_DEVICE_NAMES, advanceReview, allowRowCollisions, appendEvolutionEvent, applyCuratorFields, applyCuratorLifecycleFields, applyCuratorMetaFields, assessStructureHealth, authoringFeedback, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpUse, bumpView, clampedNumber, composePresetComposition, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, createGateSet, duplicateHeadings, emptyRecord, evaluateThreat, eventsFile, evolutionHome, evolutionIoAdapter, evolutionRoot, findDriftSignal, foldCuratorFields, foldTurn, frontmatterBlock, frontmatterYamlUnsafeValues, getRecord, latestActivityAt, lifecycleCandidate, listEventArchives, loadMutations, loadSuppressedNames, loadUsage, makeSerialQueue, markAgentCreated, markerEntryName, memoryRoot, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, observeEvent, overlongLines, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, pendingSelfCleanup, readEvolutionEvents, readEvolutionTimeline, recordMutation, redactSecrets, relatedSkillNames, renameWithRetry, renderCuratorReportMarkdown, resolveOrigins, resolveSkillsRoot, retainEventArchives, reviewPrompt, saveSuppressedNames, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, skillsRoot, suppressedFile, transactIo, updateSuppressedNames, usageFile, usageObserved, validateFrontmatter, verifyPromptBundle, writeDurableTmp, yamlPlainScalarNeedsQuotes };

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

@@ -228,6 +228,13 @@ export interface AuthoringFeedback {
  * truncated or route-poor instead of silently shipping it.
  */
 export declare function authoringFeedback(frontmatter: Frontmatter): AuthoringFeedback;
+/** C-18: win32 reserves these stems with ANY extension (`nul.md` hits the
+ * NUL device), and they are fully inside the charset above — so the reserved
+ * set is checked on the first-dot prefix as well; the charset close alone
+ * cannot refuse them. Exported single source: `badName` (skill directories,
+ * P2-11/v15) and `validateSupportPath` (support-file stems, C-18) both
+ * consume this one set — a third copy would drift. */
+export declare const WIN32_RESERVED_DEVICE_NAMES: ReadonlySet<string>;
 export declare class SkillLibrary {
     readonly root: string;
     readonly limits: SkillLimits;
@@ -339,6 +346,47 @@ export declare class SkillLibrary {
     private updateCore;
     patch(rawName: string, oldString: string, newString: string, filePath?: string, replaceAll?: boolean, origin?: WriteOrigin): Promise<SkillActionResult>;
     private patchCore;
+    /**
+     * P2-9 (v15): the destructive directory move shared by archive and
+     * restoreFromArchive — rename first, copy+remove fallback when the backend
+     * cannot rename across media (V5-35), with the E-14 rollback when the
+     * fallback's source removal fails. Returns a failure MESSAGE on a failed
+     * move (caller wraps into a structured result) or undefined on success.
+     */
+    private moveDir;
+    /**
+     * P2 (v16): the write-lock probe for the DESTRUCTIVE MOVERS (archive /
+     * restoreFromArchive). A byte-writer mid-flight is the ghost-generator —
+     * after the move its transact commit re-creates `<dir>/…` (mkdir
+     * recursive) and the tree ends half-archived. The signal is the writer's
+     * own lock file, and its PLACEMENT (inside the moved directory) is why the
+     * mover must PROBE-and-REFUSE instead of acquiring it: an acquired lock
+     * would be renamed into `.archive` with the tree, stranding a phantom live
+     * lock (the v16 audit proved the probe→rename TOCTOU does exactly that,
+     * and restore would later move the residue back into the live root).
+     * Coverage: `SKILL.md.lock` (update/patch of the body) plus one level of
+     * each support dir (write_file's lock sits next to its file). Residual:
+     * NESTED support-subdir locks and the probe→rename TOCTOU itself remain
+     * fail-safe (renameWithRetry rides the write out; the writer's locked
+     * re-read refuses on the moved-away file), and a residue `.lock` from a
+     * CRASHED writer also refuses — correct: inspect, don't archive.
+     */
+    private hasWriteLock;
+    /** P2 (v17): a file only counts as a writer lock when its body has the
+     * `pid:token` shape the io layer writes. User support files legitimately
+     * named `*.lock` (allowed by SUPPORT_FILE_NAME_RE) must not trip the probe
+     * or be swept as residue — the v16 first cut matched on suffix alone,
+     * which permanently refused archiving and deleted user content on restore. */
+    private isWriterLock;
+    /** P2 (v16): best-effort removal of lock residue inside a RESTORED tree —
+     * a `.lock` that a pre-restore crash or TOCTOU stranded in `.archive`
+     * cannot have a live writer (restore refuses when the live root is
+     * locked), and if left in place its body (a live pid on a single-host
+     * deployment) structurally closes the writer's self-heal path. */
+    private deleteStrandedLocks;
+    /** Remove `lockPath` only when its body has the writer-lock `pid:token`
+     * shape; anything else (a user support file) is left untouched. */
+    private sweepLockIfStranded;
     archive(rawName: string, options?: ArchiveOptions): Promise<SkillActionResult>;
     /**
      * Merge the bodies of `sources` into `target` and archive the sources with

package/lib/types/usage.d.ts

@@ -18,6 +18,16 @@ export interface UsageRecord {
     archived_at: string | null;
     quality_score?: number | undefined;
     quality_warn?: boolean | undefined;
+    /** P1-1 (v15): feedback-owned quality signal. Field ownership contract —
+     * `quality_score`/`quality_warn` are written ONLY by the curator's
+     * six-factor `scoreTree`; `feedback_score`/`feedback_warn` are written ONLY
+     * by the feedback channel (`SkillUsageRegistry.setFeedbackQuality`);
+     * `foldCuratorFields` refreshes the quality_* pair tree-wide and must never
+     * touch feedback_*. The lifecycle engine and the scope view read the UNION
+     * of both warn flags, which is what makes negative feedback decision-
+     * relevant again. */
+    feedback_score?: number | undefined;
+    feedback_warn?: boolean | undefined;
 }
 export type UsageMap = Map<string, UsageRecord>;
 export declare function usageFile(root: string): string;
@@ -60,6 +70,9 @@ export declare function applyCuratorLifecycleFields(disk: UsageRecord, curated:
  * Copy the recomputed meta pair (quality_score/quality_warn + the
  * marker-mirrored pin flag) — refreshed tree-wide each run by design, so a
  * concurrent curator run's lifecycle changes are never reverted by them.
+ * P1-1 (v15): the feedback pair (`feedback_score`/`feedback_warn`) is
+ * deliberately NOT copied — it is feedback-owned (see the field-ownership
+ * contract on {@link UsageRecord}) and must survive curator runs untouched.
  */
 export declare function applyCuratorMetaFields(disk: UsageRecord, curated: UsageRecord): void;
 /**

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.3.62",
+  "version": "0.3.63",
   "publishConfig": {
     "access": "public"
   },