@mulmoclaude/core 0.1.0

package/dist/workspace-setup/index.js

@@ -0,0 +1,556 @@
+import { PRESET_SLUG_PREFIX, isPresetSlug } from "./slug.js";
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/workspace-setup/sync.ts
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function copyDirTreeSync(srcDir, destDir) {
+	mkdirSync(destDir, { recursive: true });
+	for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+		const srcPath = path.join(srcDir, entry.name);
+		const destPath = path.join(destDir, entry.name);
+		if (entry.isDirectory()) copyDirTreeSync(srcPath, destPath);
+		else if (entry.isFile()) copyFileSync(srcPath, destPath);
+	}
+}
+var SKILL_FILENAME = "SKILL.md";
+function classifySourceEntry(sourceDir, entry) {
+	if (entry.startsWith(".")) return {
+		ok: false,
+		reason: "hidden",
+		silent: true
+	};
+	const slugDir = path.join(sourceDir, entry);
+	let dirInfo;
+	try {
+		dirInfo = statSync(slugDir);
+	} catch {
+		return {
+			ok: false,
+			reason: "stat failed",
+			silent: true
+		};
+	}
+	if (!dirInfo.isDirectory()) return {
+		ok: false,
+		reason: "not a directory",
+		silent: true
+	};
+	if (!isPresetSlug(entry)) return {
+		ok: false,
+		reason: `slug must start with "mc-"`,
+		silent: false
+	};
+	const skillPath = path.join(slugDir, SKILL_FILENAME);
+	let skillInfo;
+	try {
+		skillInfo = statSync(skillPath);
+	} catch {
+		return {
+			ok: false,
+			reason: `missing ${SKILL_FILENAME}`,
+			silent: false
+		};
+	}
+	if (!skillInfo.isFile()) return {
+		ok: false,
+		reason: `${SKILL_FILENAME} must be a regular file`,
+		silent: false
+	};
+	return { ok: true };
+}
+/** Prepare the destination slug dir. Returns false if the slot is
+*  occupied by a regular file (local corruption / hand edits) — the
+*  caller logs + skips so one bad entry can't crash the whole boot
+*  (Codex review iter-1). */
+function ensureDestSlugDir(destSlugDir) {
+	let info;
+	try {
+		info = statSync(destSlugDir);
+	} catch {
+		mkdirSync(destSlugDir, { recursive: true });
+		return true;
+	}
+	return info.isDirectory();
+}
+var REAL_FS_OPS = {
+	copyTree: copyDirTreeSync,
+	rename: renameSync,
+	remove: (target) => rmSync(target, {
+		recursive: true,
+		force: true
+	}),
+	exists: existsSync
+};
+/** Refresh one preset slot as a rollback-safe stage-and-swap. Wipe-and-replace
+*  (not merge) so stale sibling assets — e.g. a schema.json dropped between
+*  releases — don't linger; the catalog preset slot is launcher-owned, so user
+*  edits there are not preserved across boots.
+*
+*  The live slot is never left without a recoverable copy:
+*    1. Stage: copy the source into a temp sibling. A copy failure leaves the
+*       existing preset untouched (temp dir removed).
+*    2. Move the existing tree ASIDE to a backup (rename, not delete), so the
+*       old contents survive even if the next step fails.
+*    3. Move the staged copy into place. On failure, restore from the backup;
+*       if even the restore fails, BOTH backup and staging are preserved for
+*       manual recovery rather than deleted.
+*    4. On success, drop the backup.
+*
+*  Exported with a `_` prefix only so the rename-failure-after-move path can be
+*  regression-tested via the injected `fsOps`. Throws on failure (caller records
+*  + skips). */
+function _replaceSlugTree(sourceSlugDir, destSlugDir, fsOps = REAL_FS_OPS) {
+	const staging = `${destSlugDir}.tmp-${randomUUID()}`;
+	try {
+		fsOps.copyTree(sourceSlugDir, staging);
+	} catch (err) {
+		fsOps.remove(staging);
+		throw err;
+	}
+	const backup = `${destSlugDir}.bak-${randomUUID()}`;
+	let backedUp = false;
+	if (fsOps.exists(destSlugDir)) try {
+		fsOps.rename(destSlugDir, backup);
+		backedUp = true;
+	} catch (err) {
+		fsOps.remove(staging);
+		throw err;
+	}
+	try {
+		fsOps.rename(staging, destSlugDir);
+	} catch (err) {
+		if (backedUp) try {
+			fsOps.rename(backup, destSlugDir);
+			fsOps.remove(staging);
+		} catch {}
+		else fsOps.remove(staging);
+		throw err;
+	}
+	if (backedUp) fsOps.remove(backup);
+}
+function copySourcesIntoDest(sourceDir, destDir, opts, result) {
+	const keep = /* @__PURE__ */ new Set();
+	for (const entry of readdirSync(sourceDir)) {
+		const verdict = classifySourceEntry(sourceDir, entry);
+		if (!verdict.ok) {
+			if (!verdict.silent) {
+				result.skipped.push(`${entry}: ${verdict.reason}`);
+				opts.onWarn?.("preset entry skipped", {
+					slug: entry,
+					reason: verdict.reason
+				});
+			}
+			continue;
+		}
+		const destSlugDir = path.join(destDir, entry);
+		if (!ensureDestSlugDir(destSlugDir)) {
+			const reason = "destination slot occupied by a non-directory; skipping";
+			result.skipped.push(`${entry}: ${reason}`);
+			opts.onWarn?.("preset entry skipped", {
+				slug: entry,
+				reason,
+				destSlugDir
+			});
+			continue;
+		}
+		keep.add(entry);
+		try {
+			_replaceSlugTree(path.join(sourceDir, entry), destSlugDir);
+			result.copied.push(entry);
+		} catch (err) {
+			const reason = err instanceof Error ? err.message : String(err);
+			result.skipped.push(`${entry}: ${reason}`);
+			opts.onWarn?.("preset copy failed, skipping", {
+				slug: entry,
+				reason
+			});
+		}
+	}
+	return keep;
+}
+function removeRetiredPresets(destDir, keep, opts, result) {
+	for (const entry of readdirSync(destDir)) {
+		if (!isPresetSlug(entry)) continue;
+		if (keep.has(entry)) continue;
+		const stalePath = path.join(destDir, entry);
+		try {
+			if (!statSync(stalePath).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		rmSync(stalePath, {
+			recursive: true,
+			force: true
+		});
+		result.removed.push(entry);
+		opts.onInfo?.("removed retired preset skill", { slug: entry });
+	}
+}
+/** Copy every preset slug from `sourceDir` into `destDir` (the
+*  preset slot under the catalog root), then remove any `mc-*`
+*  entries in `destDir` that no longer have a source. The catalog
+*  preset subdir is fully launcher-owned, so the `mc-*` prefix
+*  check at destination is defence-in-depth: a stray non-preset
+*  slug landing in `catalog/preset/` is unexpected, and we'd
+*  rather skip it than silently delete a directory we don't
+*  recognise. */
+function syncPresetSkills(opts) {
+	const result = {
+		copied: [],
+		removed: [],
+		skipped: []
+	};
+	if (!existsSync(opts.sourceDir)) return result;
+	let sourceInfo;
+	try {
+		sourceInfo = statSync(opts.sourceDir);
+	} catch (err) {
+		const reason = `source path stat failed: ${errorMessage(err)}`;
+		result.skipped.push(`${opts.sourceDir}: ${reason}`);
+		opts.onWarn?.("preset sync aborted", {
+			sourceDir: opts.sourceDir,
+			reason
+		});
+		return result;
+	}
+	if (!sourceInfo.isDirectory()) {
+		const reason = "source path exists as a non-directory; preset sync skipped";
+		result.skipped.push(`${opts.sourceDir}: ${reason}`);
+		opts.onWarn?.("preset sync aborted", {
+			sourceDir: opts.sourceDir,
+			reason
+		});
+		return result;
+	}
+	if (!ensureDestSlugDir(opts.destDir)) {
+		const reason = "root dest exists as a non-directory; preset sync skipped";
+		result.skipped.push(`${opts.destDir}: ${reason}`);
+		opts.onWarn?.("preset sync aborted", {
+			destDir: opts.destDir,
+			reason
+		});
+		return result;
+	}
+	const keep = copySourcesIntoDest(opts.sourceDir, opts.destDir, opts, result);
+	removeRetiredPresets(opts.destDir, keep, opts, result);
+	if (result.copied.length > 0 || result.removed.length > 0) opts.onInfo?.("preset skills synced", {
+		copied: result.copied.length,
+		removed: result.removed.length,
+		skipped: result.skipped.length
+	});
+	return result;
+}
+function filesEqual(left, right) {
+	try {
+		return readFileSync(left).equals(readFileSync(right));
+	} catch {
+		return false;
+	}
+}
+/** Copy `srcPath` over `destPath`. If `destPath` already exists and
+*  differs, rename it to `destPath + backupExt` first so the user's
+*  prior contents are recoverable. If `destPath` doesn't exist, just
+*  copy (no backup needed). Pure: no logging here — caller decides. */
+function syncOneFile(srcPath, destPath, backupExt) {
+	let destExists;
+	try {
+		destExists = statSync(destPath).isFile();
+	} catch {
+		destExists = false;
+	}
+	if (!destExists) try {
+		copyFileSync(srcPath, destPath);
+		return "updated";
+	} catch {
+		return "skipped";
+	}
+	if (filesEqual(srcPath, destPath)) return "unchanged";
+	try {
+		renameSync(destPath, destPath + backupExt);
+		copyFileSync(srcPath, destPath);
+		return "updated";
+	} catch {
+		return "skipped";
+	}
+}
+function syncDirTreeDiff(srcDir, destDir, backupExt) {
+	const stats = {
+		updated: 0,
+		unchanged: 0,
+		skipped: 0
+	};
+	try {
+		mkdirSync(destDir, { recursive: true });
+	} catch {
+		stats.skipped++;
+		return stats;
+	}
+	let entries;
+	try {
+		entries = readdirSync(srcDir, { withFileTypes: true });
+	} catch {
+		stats.skipped++;
+		return stats;
+	}
+	for (const entry of entries) {
+		const srcPath = path.join(srcDir, entry.name);
+		const destPath = path.join(destDir, entry.name);
+		if (entry.isDirectory()) {
+			const sub = syncDirTreeDiff(srcPath, destPath, backupExt);
+			stats.updated += sub.updated;
+			stats.unchanged += sub.unchanged;
+			stats.skipped += sub.skipped;
+		} else if (entry.isFile()) {
+			const outcome = syncOneFile(srcPath, destPath, backupExt);
+			stats[outcome]++;
+		}
+	}
+	return stats;
+}
+function abortActiveSync(opts, result, reason) {
+	result.skipped.push(`${opts.sourceDir}: ${reason}`);
+	opts.onWarn?.("active preset sync aborted", {
+		sourceDir: opts.sourceDir,
+		reason
+	});
+	return result;
+}
+/** True iff `absPath`'s realpath resolves inside `rootPath`'s
+*  realpath. Defends `processActiveSlug` against a starred `mc-*`
+*  slug that's actually a symlink to somewhere outside
+*  `activeDir`: without this check, the recursive copy below would
+*  follow the symlink and write through to the link's target
+*  (potentially anywhere on disk). Returns false on any error so
+*  the caller treats unreadable paths as "refused" rather than
+*  "OK to write". */
+function isRealpathInside(absPath, rootPath) {
+	try {
+		const real = realpathSync(absPath);
+		const rootReal = realpathSync(rootPath);
+		return real === rootReal || real.startsWith(rootReal + path.sep);
+	} catch {
+		return false;
+	}
+}
+/** Validate the active dest slug dir before writing through it.
+*  Returns:
+*   - `{ ok: true }`           — proceed with the sync
+*   - `{ kind: "not-active" }` — slug hasn't been starred yet
+*   - `{ ok: false; reason }`  — refuse to write (symlink escape,
+*                                non-directory, ancestor escape)
+*
+*  Symlink defenses (Codex P1 review on PR #1490): `statSync`
+*  follows symlinks, so a starred `mc-*` slug that's actually a
+*  symlink to /etc would let the recursive copy below write
+*  outside the workspace. Two-layer defense:
+*   1. `lstatSync` to see the link itself; if it's a symlink,
+*      only accept when its target stays inside `activeDir`.
+*   2. Always realpath-verify the full path (catches the case
+*      where an ancestor like `.claude/` is symlinked even when
+*      the slug dir itself is a regular directory). */
+function classifyActiveDest(slug, destSlugDir, activeDir) {
+	let destInfo;
+	try {
+		destInfo = lstatSync(destSlugDir);
+	} catch {
+		return { kind: "not-active" };
+	}
+	if (destInfo.isSymbolicLink()) {
+		if (!isRealpathInside(destSlugDir, activeDir)) return {
+			ok: false,
+			reason: "active slot is a symlink whose target escapes activeDir; refusing to write through it"
+		};
+		return { ok: true };
+	}
+	if (!destInfo.isDirectory()) return {
+		ok: false,
+		reason: "active slot is occupied by a non-directory; skipping"
+	};
+	if (!isRealpathInside(destSlugDir, activeDir)) return {
+		ok: false,
+		reason: "active slug dir escapes activeDir via an ancestor symlink"
+	};
+	return { ok: true };
+}
+/** Per-slug worker for `syncActivePresetSkills`. Extracted to keep
+*  the outer function under the `sonarjs/cognitive-complexity`
+*  threshold; no behavior difference vs the inline loop. */
+function processActiveSlug(slug, opts, result, backupExt) {
+	const srcSlugDir = path.join(opts.sourceDir, slug);
+	try {
+		if (!statSync(srcSlugDir).isDirectory()) return;
+	} catch {
+		return;
+	}
+	const destSlugDir = path.join(opts.activeDir, slug);
+	const verdict = classifyActiveDest(slug, destSlugDir, opts.activeDir);
+	if ("kind" in verdict) {
+		result.notActive.push(slug);
+		return;
+	}
+	if (!verdict.ok) {
+		result.skipped.push(`${slug}: ${verdict.reason}`);
+		opts.onWarn?.("active preset sync skipped", {
+			slug,
+			reason: verdict.reason,
+			destSlugDir
+		});
+		return;
+	}
+	const stats = syncDirTreeDiff(srcSlugDir, destSlugDir, backupExt);
+	if (stats.updated > 0) {
+		result.updated.push(slug);
+		opts.onInfo?.("active preset skill updated from source", {
+			slug,
+			files: stats.updated,
+			backupSuffix: backupExt
+		});
+	} else if (stats.skipped === 0) result.unchanged.push(slug);
+	if (stats.skipped > 0) {
+		result.skipped.push(`${slug}: ${stats.skipped} file(s) skipped`);
+		opts.onWarn?.("active preset skill partial update", {
+			slug,
+			skipped: stats.skipped
+		});
+	}
+}
+/** Realpath targets of active symlinks. Used so the prune below never
+*  deletes a directory that's serving as a symlink target (e.g. a
+*  git-managed checkout the user symlinks an active slug to). */
+function collectSymlinkTargets(activeDir, entries) {
+	const targets = /* @__PURE__ */ new Set();
+	for (const slug of entries) {
+		const entryPath = path.join(activeDir, slug);
+		try {
+			if (lstatSync(entryPath).isSymbolicLink()) targets.add(realpathSync(entryPath));
+		} catch {}
+	}
+	return targets;
+}
+/** True iff the active `slug` is a retired preset safe to delete: an
+*  `mc-*` real directory inside `activeDir`, with no source preset, and
+*  not itself a symlink or a symlink target. */
+function isRetiredActiveSlug(slug, activeDir, sourceSlugs, symlinkTargets) {
+	if (!isPresetSlug(slug) || sourceSlugs.has(slug)) return false;
+	const destSlugDir = path.join(activeDir, slug);
+	let info;
+	try {
+		info = lstatSync(destSlugDir);
+	} catch {
+		return false;
+	}
+	if (info.isSymbolicLink() || !info.isDirectory()) return false;
+	if (!isRealpathInside(destSlugDir, activeDir)) return false;
+	try {
+		return !symlinkTargets.has(realpathSync(destSlugDir));
+	} catch {
+		return false;
+	}
+}
+/** Prune active `mc-*` slugs whose launcher source preset no longer
+*  exists (a retired preset). Without this, an upgraded workspace that
+*  had starred a since-removed preset (e.g. `mc-manage-sources`) keeps
+*  the active copy forever — Claude would still discover a skill whose
+*  backend was deleted. Bounded to `mc-*` real directories that stay
+*  inside `activeDir` (never a symlink escape, never a user skill). */
+function removeRetiredActivePresets(opts, result, sourceSlugs) {
+	let activeEntries;
+	try {
+		activeEntries = readdirSync(opts.activeDir);
+	} catch {
+		return;
+	}
+	const symlinkTargets = collectSymlinkTargets(opts.activeDir, activeEntries);
+	for (const slug of activeEntries) {
+		if (!isRetiredActiveSlug(slug, opts.activeDir, sourceSlugs, symlinkTargets)) continue;
+		try {
+			rmSync(path.join(opts.activeDir, slug), {
+				recursive: true,
+				force: true
+			});
+			result.removed.push(slug);
+			opts.onInfo?.("removed retired active preset skill", { slug });
+		} catch (err) {
+			result.skipped.push(`${slug}: prune failed: ${errorMessage(err)}`);
+			opts.onWarn?.("active preset prune failed", {
+				slug,
+				reason: errorMessage(err)
+			});
+		}
+	}
+}
+/** Refresh every already-starred `mc-*` preset's active copy in
+*  `<workspaceRoot>/.claude/skills/<slug>/` to match the source.
+*  Per-file diff with `.bak.<timestamp>` backup on overwrite. Slugs
+*  that aren't starred yet are listed in `notActive` but never
+*  auto-created. */
+function syncActivePresetSkills(opts) {
+	const result = {
+		updated: [],
+		unchanged: [],
+		notActive: [],
+		removed: [],
+		skipped: [],
+		backupSuffix: null
+	};
+	if (!existsSync(opts.sourceDir)) return result;
+	let sourceInfo;
+	try {
+		sourceInfo = statSync(opts.sourceDir);
+	} catch (err) {
+		return abortActiveSync(opts, result, `source path stat failed: ${errorMessage(err)}`);
+	}
+	if (!sourceInfo.isDirectory()) return abortActiveSync(opts, result, "source path exists as a non-directory; active preset sync skipped");
+	let sourceEntries;
+	try {
+		sourceEntries = readdirSync(opts.sourceDir);
+	} catch (err) {
+		return abortActiveSync(opts, result, `source readdir failed: ${errorMessage(err)}`);
+	}
+	const backupExt = `.bak.${Date.now()}`;
+	result.backupSuffix = backupExt;
+	const sourceSlugs = /* @__PURE__ */ new Set();
+	for (const slug of sourceEntries) {
+		if (slug.startsWith(".")) continue;
+		if (!isPresetSlug(slug)) continue;
+		sourceSlugs.add(slug);
+		processActiveSlug(slug, opts, result, backupExt);
+	}
+	removeRetiredActivePresets(opts, result, sourceSlugs);
+	if (result.updated.length > 0 || result.removed.length > 0) opts.onInfo?.("active preset skills synced", {
+		updated: result.updated.length,
+		unchanged: result.unchanged.length,
+		notActive: result.notActive.length,
+		removed: result.removed.length,
+		skipped: result.skipped.length,
+		backupSuffix: backupExt
+	});
+	return result;
+}
+//#endregion
+//#region src/workspace-setup/assets.ts
+var ASSETS_DIR = fileURLToPath(new URL("../../assets", "" + import.meta.url));
+/** The bundled help-docs source dir (`assets/helps/`). */
+function helpsAssetDir() {
+	return path.join(ASSETS_DIR, "helps");
+}
+/** The bundled preset-skills source dir (`assets/skills-preset/`) — pass as the
+*  `sourceDir` of `syncPresetSkills` / `syncActivePresetSkills`. */
+function presetSkillsAssetDir() {
+	return path.join(ASSETS_DIR, "skills-preset");
+}
+/** Copy every bundled help doc into `destDir` (created if missing). Idempotent —
+*  overwrites on each call so the help docs always track the package's version. */
+function seedHelps(opts) {
+	mkdirSync(opts.destDir, { recursive: true });
+	const src = helpsAssetDir();
+	for (const file of readdirSync(src)) copyFileSync(path.join(src, file), path.join(opts.destDir, file));
+}
+//#endregion
+export { PRESET_SLUG_PREFIX, _replaceSlugTree, helpsAssetDir, isPresetSlug, presetSkillsAssetDir, seedHelps, syncActivePresetSkills, syncPresetSkills };
+
+//# sourceMappingURL=index.js.map

package/dist/workspace-setup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/workspace-setup/sync.ts","../../src/workspace-setup/assets.ts"],"sourcesContent":["// Preset skills bundled with mulmoclaude.\n//\n// History: introduced in #1210 to ship launcher-managed \"factory\"\n// skills like `mc-library`. Originally synced straight into\n// `<workspaceRoot>/.claude/skills/<slug>/`, which made every preset\n// auto-active and inflated the Claude system prompt as new presets\n// landed.\n//\n// #1335 PR-A flipped the destination to the catalog\n// (`<workspaceRoot>/data/skills/catalog/preset/<slug>/`). Catalog\n// entries are visible to UI / tooling but NOT discovered by Claude\n// Code's slash-command resolver — they don't enter the system\n// prompt unless the user (or a later UI in PR-B) explicitly copies\n// one into `.claude/skills/`.\n//\n// The launcher overwrites catalog entries unconditionally on every\n// boot — they're factory defaults, not user state. Anything in\n// `.claude/skills/` (active layer) is left untouched.\n//\n// `syncPresetSkills(...)` is exported as a pure-ish helper (takes\n// paths + a logger sink, returns a summary) so tests can drive it\n// against tmpdirs without touching a real workspace.\n\nimport { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, type Dirent } from \"node:fs\";\nimport { randomUUID } from \"node:crypto\";\nimport path from \"node:path\";\nimport { PRESET_SLUG_PREFIX, isPresetSlug } from \"./slug.js\";\n\n// Inlined (was the host's ../utils/errors.js) so the package has no host coupling.\nfunction errorMessage(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\n// Recursively mirror `srcDir` into `destDir`. Used by the preset\n// sync so a preset skill that ships sibling assets (e.g.\n// `schema.json` for schema-driven apps, `templates/*.html`) gets\n// copied alongside `SKILL.md` rather than silently dropped. Only\n// regular files and directories are followed — symlinks / FIFOs /\n// sockets are skipped because the preset tree is launcher-managed\n// and shouldn't contain them.\nfunction copyDirTreeSync(srcDir: string, destDir: string): void {\n  mkdirSync(destDir, { recursive: true });\n  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {\n    const srcPath = path.join(srcDir, entry.name);\n    const destPath = path.join(destDir, entry.name);\n    if (entry.isDirectory()) {\n      copyDirTreeSync(srcPath, destPath);\n    } else if (entry.isFile()) {\n      copyFileSync(srcPath, destPath);\n    }\n  }\n}\n\nconst SKILL_FILENAME = \"SKILL.md\";\n\nexport interface SyncPresetSkillsOptions {\n  /** Source directory: `<launcher>/server/workspace/skills-preset/`. */\n  sourceDir: string;\n  /** Destination directory:\n   *  `<workspaceRoot>/data/skills/catalog/preset/`. The catalog\n   *  half of the catalog-vs-active split — entries here are visible\n   *  to UI but NOT to Claude Code's prompt-time skill resolver. */\n  destDir: string;\n  /** Logger callbacks — kept injectable so tests don't need to\n   *  spin up the structured logger. The boot-side wrapper threads\n   *  these through to `log.info` / `log.warn`. */\n  onInfo?: (message: string, data?: Record<string, unknown>) => void;\n  onWarn?: (message: string, data?: Record<string, unknown>) => void;\n}\n\nexport interface SyncPresetSkillsResult {\n  /** Slugs successfully copied (or refreshed) from source to dest. */\n  copied: string[];\n  /** Slugs removed from dest because they no longer exist in source.\n   *  Bounded to `mc-*` entries — user-authored slugs are never\n   *  considered for removal. */\n  removed: string[];\n  /** Source entries that failed validation (wrong prefix, missing\n   *  SKILL.md, etc.) and were skipped. Each entry is human-readable. */\n  skipped: string[];\n}\n\n// Classification of one source entry. `silent` distinguishes\n// structural skips (hidden files, non-directory entries — not the\n// dev's fault) from misconfigurations (bad slug, missing or\n// non-regular SKILL.md — the dev WANTS to know). The boolean lives\n// on the verdict so the caller never has to string-match `reason`,\n// which would silently drop warnings if reason wording changed\n// (CodeRabbit review).\ntype Verdict = { ok: true } | { ok: false; reason: string; silent: boolean };\n\nfunction classifySourceEntry(sourceDir: string, entry: string): Verdict {\n  if (entry.startsWith(\".\")) return { ok: false, reason: \"hidden\", silent: true };\n  const slugDir = path.join(sourceDir, entry);\n  let dirInfo;\n  try {\n    dirInfo = statSync(slugDir);\n  } catch {\n    return { ok: false, reason: \"stat failed\", silent: true };\n  }\n  if (!dirInfo.isDirectory()) return { ok: false, reason: \"not a directory\", silent: true };\n  if (!isPresetSlug(entry)) return { ok: false, reason: `slug must start with \"${PRESET_SLUG_PREFIX}\"`, silent: false };\n  // Validate SKILL.md is a regular file — `existsSync` alone\n  // accepts a directory at that path, which would then crash\n  // copyFileSync. Codex review caught this edge case.\n  const skillPath = path.join(slugDir, SKILL_FILENAME);\n  let skillInfo;\n  try {\n    skillInfo = statSync(skillPath);\n  } catch {\n    return { ok: false, reason: `missing ${SKILL_FILENAME}`, silent: false };\n  }\n  if (!skillInfo.isFile()) return { ok: false, reason: `${SKILL_FILENAME} must be a regular file`, silent: false };\n  return { ok: true };\n}\n\n/** Prepare the destination slug dir. Returns false if the slot is\n *  occupied by a regular file (local corruption / hand edits) — the\n *  caller logs + skips so one bad entry can't crash the whole boot\n *  (Codex review iter-1). */\nfunction ensureDestSlugDir(destSlugDir: string): boolean {\n  let info;\n  try {\n    info = statSync(destSlugDir);\n  } catch {\n    mkdirSync(destSlugDir, { recursive: true });\n    return true;\n  }\n  return info.isDirectory();\n}\n\n/** Filesystem ops `_replaceSlugTree` depends on — injectable so the\n *  mid-swap failure path can be regression-tested without real IO faults. */\nexport interface SlugTreeFsOps {\n  copyTree: (src: string, dest: string) => void;\n  rename: (from: string, dest: string) => void;\n  remove: (target: string) => void;\n  exists: (target: string) => boolean;\n}\n\nconst REAL_FS_OPS: SlugTreeFsOps = {\n  copyTree: copyDirTreeSync,\n  rename: renameSync,\n  remove: (target) => rmSync(target, { recursive: true, force: true }),\n  exists: existsSync,\n};\n\n/** Refresh one preset slot as a rollback-safe stage-and-swap. Wipe-and-replace\n *  (not merge) so stale sibling assets — e.g. a schema.json dropped between\n *  releases — don't linger; the catalog preset slot is launcher-owned, so user\n *  edits there are not preserved across boots.\n *\n *  The live slot is never left without a recoverable copy:\n *    1. Stage: copy the source into a temp sibling. A copy failure leaves the\n *       existing preset untouched (temp dir removed).\n *    2. Move the existing tree ASIDE to a backup (rename, not delete), so the\n *       old contents survive even if the next step fails.\n *    3. Move the staged copy into place. On failure, restore from the backup;\n *       if even the restore fails, BOTH backup and staging are preserved for\n *       manual recovery rather than deleted.\n *    4. On success, drop the backup.\n *\n *  Exported with a `_` prefix only so the rename-failure-after-move path can be\n *  regression-tested via the injected `fsOps`. Throws on failure (caller records\n *  + skips). */\nexport function _replaceSlugTree(sourceSlugDir: string, destSlugDir: string, fsOps: SlugTreeFsOps = REAL_FS_OPS): void {\n  const staging = `${destSlugDir}.tmp-${randomUUID()}`;\n  try {\n    fsOps.copyTree(sourceSlugDir, staging);\n  } catch (err) {\n    fsOps.remove(staging); // dest untouched\n    throw err;\n  }\n  const backup = `${destSlugDir}.bak-${randomUUID()}`;\n  let backedUp = false;\n  if (fsOps.exists(destSlugDir)) {\n    try {\n      fsOps.rename(destSlugDir, backup);\n      backedUp = true;\n    } catch (err) {\n      fsOps.remove(staging); // dest untouched; nothing was moved\n      throw err;\n    }\n  }\n  try {\n    fsOps.rename(staging, destSlugDir);\n  } catch (err) {\n    if (backedUp) {\n      try {\n        fsOps.rename(backup, destSlugDir); // roll back to the previous tree\n        fsOps.remove(staging);\n      } catch {\n        // Rollback failed — preserve BOTH backup and staging for manual\n        // recovery rather than leaving the slot empty.\n      }\n    } else {\n      fsOps.remove(staging); // dest never existed; nothing to restore\n    }\n    throw err;\n  }\n  if (backedUp) fsOps.remove(backup);\n}\n\nfunction copySourcesIntoDest(sourceDir: string, destDir: string, opts: SyncPresetSkillsOptions, result: SyncPresetSkillsResult): Set<string> {\n  // `keep` is the set of slugs the retirement pass must NOT prune. It tracks\n  // valid SOURCE slugs (present + usable dest slot), NOT successful copies — so\n  // a slug whose refresh fails transiently keeps its existing contents (left\n  // intact by the stage-and-swap above) instead of being pruned as \"retired\".\n  const keep = new Set<string>();\n  for (const entry of readdirSync(sourceDir)) {\n    const verdict = classifySourceEntry(sourceDir, entry);\n    if (!verdict.ok) {\n      if (!verdict.silent) {\n        result.skipped.push(`${entry}: ${verdict.reason}`);\n        opts.onWarn?.(\"preset entry skipped\", { slug: entry, reason: verdict.reason });\n      }\n      continue;\n    }\n    const destSlugDir = path.join(destDir, entry);\n    if (!ensureDestSlugDir(destSlugDir)) {\n      const reason = \"destination slot occupied by a non-directory; skipping\";\n      result.skipped.push(`${entry}: ${reason}`);\n      opts.onWarn?.(\"preset entry skipped\", { slug: entry, reason, destSlugDir });\n      continue;\n    }\n    // The slug exists in source with a usable dest slot — keep it regardless of\n    // whether the refresh below succeeds, so a transient failure doesn't get it\n    // pruned by `removeRetiredPresets`.\n    keep.add(entry);\n    // Per-slug isolation: a transient IO error / permission issue / partial\n    // corruption on one preset must not abort syncing the rest, nor destroy\n    // the existing copy. Skip the offender (recorded) and continue.\n    try {\n      _replaceSlugTree(path.join(sourceDir, entry), destSlugDir);\n      result.copied.push(entry);\n    } catch (err) {\n      const reason = err instanceof Error ? err.message : String(err);\n      result.skipped.push(`${entry}: ${reason}`);\n      opts.onWarn?.(\"preset copy failed, skipping\", { slug: entry, reason });\n    }\n  }\n  return keep;\n}\n\nfunction removeRetiredPresets(destDir: string, keep: ReadonlySet<string>, opts: SyncPresetSkillsOptions, result: SyncPresetSkillsResult): void {\n  for (const entry of readdirSync(destDir)) {\n    if (!isPresetSlug(entry)) continue;\n    if (keep.has(entry)) continue;\n    const stalePath = path.join(destDir, entry);\n    try {\n      if (!statSync(stalePath).isDirectory()) continue;\n    } catch {\n      continue;\n    }\n    rmSync(stalePath, { recursive: true, force: true });\n    result.removed.push(entry);\n    opts.onInfo?.(\"removed retired preset skill\", { slug: entry });\n  }\n}\n\n/** Copy every preset slug from `sourceDir` into `destDir` (the\n *  preset slot under the catalog root), then remove any `mc-*`\n *  entries in `destDir` that no longer have a source. The catalog\n *  preset subdir is fully launcher-owned, so the `mc-*` prefix\n *  check at destination is defence-in-depth: a stray non-preset\n *  slug landing in `catalog/preset/` is unexpected, and we'd\n *  rather skip it than silently delete a directory we don't\n *  recognise. */\nexport function syncPresetSkills(opts: SyncPresetSkillsOptions): SyncPresetSkillsResult {\n  const result: SyncPresetSkillsResult = { copied: [], removed: [], skipped: [] };\n  if (!existsSync(opts.sourceDir)) {\n    // No preset directory in the launcher tarball — nothing to do.\n    // This is the legitimate \"no presets shipped yet\" state.\n    return result;\n  }\n  // Source-side validation: the launcher's preset path COULD exist\n  // as a regular file (a packaging bug, a corrupted install). Without\n  // this guard, `readdirSync(sourceDir)` would throw ENOTDIR and\n  // crash boot. Codex review iter-3.\n  let sourceInfo;\n  try {\n    sourceInfo = statSync(opts.sourceDir);\n  } catch (err) {\n    const reason = `source path stat failed: ${errorMessage(err)}`;\n    result.skipped.push(`${opts.sourceDir}: ${reason}`);\n    opts.onWarn?.(\"preset sync aborted\", { sourceDir: opts.sourceDir, reason });\n    return result;\n  }\n  if (!sourceInfo.isDirectory()) {\n    const reason = \"source path exists as a non-directory; preset sync skipped\";\n    result.skipped.push(`${opts.sourceDir}: ${reason}`);\n    opts.onWarn?.(\"preset sync aborted\", { sourceDir: opts.sourceDir, reason });\n    return result;\n  }\n  // The root dest itself can be corrupted into a regular file by a\n  // user / external tool; mkdirSync would throw EEXIST and crash\n  // boot. Treat it as a recoverable \"skip the entire sync\" state\n  // — log a clear warning so the user sees what to fix.\n  // (Codex review iter-2.)\n  if (!ensureDestSlugDir(opts.destDir)) {\n    const reason = \"root dest exists as a non-directory; preset sync skipped\";\n    result.skipped.push(`${opts.destDir}: ${reason}`);\n    opts.onWarn?.(\"preset sync aborted\", { destDir: opts.destDir, reason });\n    return result;\n  }\n  const keep = copySourcesIntoDest(opts.sourceDir, opts.destDir, opts, result);\n  removeRetiredPresets(opts.destDir, keep, opts, result);\n  if (result.copied.length > 0 || result.removed.length > 0) {\n    opts.onInfo?.(\"preset skills synced\", {\n      copied: result.copied.length,\n      removed: result.removed.length,\n      skipped: result.skipped.length,\n    });\n  }\n  return result;\n}\n\n// ---------------------------------------------------------------\n// Active-layer sync: keep starred mc-* presets in lockstep with\n// their launcher-bundled source.\n//\n// Motivation: the catalog sync above refreshes\n// `data/skills/catalog/preset/<slug>/` on every boot, but once a\n// user stars an entry the active copy in\n// `<workspace>/.claude/skills/<slug>/` is never updated even when\n// the launcher ships a new SKILL.md (e.g. a typo fix or, as the\n// trigger for this code, the schema-driven-apps → collections\n// rename). The SKILL.md front-matter explicitly says\n// \"do not edit this file in the workspace, it is overwritten on\n// every server boot\" — until this function existed, that was a\n// promise the active layer didn't keep.\n//\n// Safety model:\n//   - Only `mc-*` slugs are touched (defensive prefix check —\n//     never touches user-authored skills).\n//   - Per-file diff: a file is overwritten only if its bytes\n//     differ from the source. No-op when already up to date.\n//   - User-added files inside an active slug dir are left alone\n//     (we walk the source tree, not the dest tree).\n//   - If a file IS overwritten, the previous contents are first\n//     renamed to `<file>.bak.<timestamp>` so a user who had\n//     locally tweaked the preset can recover.\n//   - A slug whose active dir doesn't exist (= not starred yet)\n//     is skipped entirely, never auto-starred.\n// ---------------------------------------------------------------\n\nexport interface SyncActivePresetSkillsOptions {\n  /** Source directory: `<launcher>/server/workspace/skills-preset/`. */\n  sourceDir: string;\n  /** Active skills directory: `<workspaceRoot>/.claude/skills/`. */\n  activeDir: string;\n  onInfo?: (message: string, data?: Record<string, unknown>) => void;\n  onWarn?: (message: string, data?: Record<string, unknown>) => void;\n}\n\nexport interface SyncActivePresetSkillsResult {\n  /** Slugs whose active copy had at least one file overwritten. */\n  updated: string[];\n  /** Slugs whose active copy already matched the source — no-op. */\n  unchanged: string[];\n  /** Slugs that haven't been starred yet (no active dir present).\n   *  Listed for diagnostics; the function never auto-stars. */\n  notActive: string[];\n  /** Active `mc-*` slugs pruned because the launcher no longer ships a\n   *  source preset for them (a retired preset). Bounded to `mc-*` —\n   *  user-authored skills are never removed. */\n  removed: string[];\n  /** Per-slug failure messages (permission errors, etc.). */\n  skipped: string[];\n  /** Common timestamp suffix used for every backup file produced by\n   *  this run. Exposed so the boot-time log can point a user at the\n   *  exact glob to inspect. */\n  backupSuffix: string | null;\n}\n\ntype FileSyncOutcome = \"updated\" | \"unchanged\" | \"skipped\";\n\nfunction filesEqual(left: string, right: string): boolean {\n  try {\n    return readFileSync(left).equals(readFileSync(right));\n  } catch {\n    return false;\n  }\n}\n\n/** Copy `srcPath` over `destPath`. If `destPath` already exists and\n *  differs, rename it to `destPath + backupExt` first so the user's\n *  prior contents are recoverable. If `destPath` doesn't exist, just\n *  copy (no backup needed). Pure: no logging here — caller decides. */\nfunction syncOneFile(srcPath: string, destPath: string, backupExt: string): FileSyncOutcome {\n  let destExists: boolean;\n  try {\n    destExists = statSync(destPath).isFile();\n  } catch {\n    destExists = false;\n  }\n  if (!destExists) {\n    try {\n      copyFileSync(srcPath, destPath);\n      return \"updated\";\n    } catch {\n      return \"skipped\";\n    }\n  }\n  if (filesEqual(srcPath, destPath)) return \"unchanged\";\n  try {\n    renameSync(destPath, destPath + backupExt);\n    copyFileSync(srcPath, destPath);\n    return \"updated\";\n  } catch {\n    return \"skipped\";\n  }\n}\n\ninterface DirSyncStats {\n  updated: number;\n  unchanged: number;\n  skipped: number;\n}\n\nfunction syncDirTreeDiff(srcDir: string, destDir: string, backupExt: string): DirSyncStats {\n  const stats: DirSyncStats = { updated: 0, unchanged: 0, skipped: 0 };\n  try {\n    mkdirSync(destDir, { recursive: true });\n  } catch {\n    stats.skipped++;\n    return stats;\n  }\n  let entries: Dirent[];\n  try {\n    entries = readdirSync(srcDir, { withFileTypes: true });\n  } catch {\n    stats.skipped++;\n    return stats;\n  }\n  for (const entry of entries) {\n    const srcPath = path.join(srcDir, entry.name);\n    const destPath = path.join(destDir, entry.name);\n    if (entry.isDirectory()) {\n      const sub = syncDirTreeDiff(srcPath, destPath, backupExt);\n      stats.updated += sub.updated;\n      stats.unchanged += sub.unchanged;\n      stats.skipped += sub.skipped;\n    } else if (entry.isFile()) {\n      const outcome = syncOneFile(srcPath, destPath, backupExt);\n      stats[outcome]++;\n    }\n    // Symlinks / sockets / FIFOs intentionally ignored (the launcher\n    // preset tree shouldn't contain them).\n  }\n  return stats;\n}\n\nfunction abortActiveSync(opts: SyncActivePresetSkillsOptions, result: SyncActivePresetSkillsResult, reason: string): SyncActivePresetSkillsResult {\n  result.skipped.push(`${opts.sourceDir}: ${reason}`);\n  opts.onWarn?.(\"active preset sync aborted\", { sourceDir: opts.sourceDir, reason });\n  return result;\n}\n\n/** True iff `absPath`'s realpath resolves inside `rootPath`'s\n *  realpath. Defends `processActiveSlug` against a starred `mc-*`\n *  slug that's actually a symlink to somewhere outside\n *  `activeDir`: without this check, the recursive copy below would\n *  follow the symlink and write through to the link's target\n *  (potentially anywhere on disk). Returns false on any error so\n *  the caller treats unreadable paths as \"refused\" rather than\n *  \"OK to write\". */\nfunction isRealpathInside(absPath: string, rootPath: string): boolean {\n  try {\n    const real = realpathSync(absPath);\n    const rootReal = realpathSync(rootPath);\n    return real === rootReal || real.startsWith(rootReal + path.sep);\n  } catch {\n    return false;\n  }\n}\n\ntype DestVerdict = { ok: true } | { ok: false; reason: string } | { kind: \"not-active\" };\n\n/** Validate the active dest slug dir before writing through it.\n *  Returns:\n *   - `{ ok: true }`           — proceed with the sync\n *   - `{ kind: \"not-active\" }` — slug hasn't been starred yet\n *   - `{ ok: false; reason }`  — refuse to write (symlink escape,\n *                                non-directory, ancestor escape)\n *\n *  Symlink defenses (Codex P1 review on PR #1490): `statSync`\n *  follows symlinks, so a starred `mc-*` slug that's actually a\n *  symlink to /etc would let the recursive copy below write\n *  outside the workspace. Two-layer defense:\n *   1. `lstatSync` to see the link itself; if it's a symlink,\n *      only accept when its target stays inside `activeDir`.\n *   2. Always realpath-verify the full path (catches the case\n *      where an ancestor like `.claude/` is symlinked even when\n *      the slug dir itself is a regular directory). */\nfunction classifyActiveDest(slug: string, destSlugDir: string, activeDir: string): DestVerdict {\n  let destInfo;\n  try {\n    destInfo = lstatSync(destSlugDir);\n  } catch {\n    return { kind: \"not-active\" };\n  }\n  if (destInfo.isSymbolicLink()) {\n    if (!isRealpathInside(destSlugDir, activeDir)) {\n      return { ok: false, reason: \"active slot is a symlink whose target escapes activeDir; refusing to write through it\" };\n    }\n    return { ok: true };\n  }\n  if (!destInfo.isDirectory()) {\n    return { ok: false, reason: \"active slot is occupied by a non-directory; skipping\" };\n  }\n  if (!isRealpathInside(destSlugDir, activeDir)) {\n    return { ok: false, reason: \"active slug dir escapes activeDir via an ancestor symlink\" };\n  }\n  return { ok: true };\n}\n\n/** Per-slug worker for `syncActivePresetSkills`. Extracted to keep\n *  the outer function under the `sonarjs/cognitive-complexity`\n *  threshold; no behavior difference vs the inline loop. */\nfunction processActiveSlug(slug: string, opts: SyncActivePresetSkillsOptions, result: SyncActivePresetSkillsResult, backupExt: string): void {\n  const srcSlugDir = path.join(opts.sourceDir, slug);\n  try {\n    if (!statSync(srcSlugDir).isDirectory()) return;\n  } catch {\n    return;\n  }\n  const destSlugDir = path.join(opts.activeDir, slug);\n  const verdict = classifyActiveDest(slug, destSlugDir, opts.activeDir);\n  if (\"kind\" in verdict) {\n    result.notActive.push(slug);\n    return;\n  }\n  if (!verdict.ok) {\n    result.skipped.push(`${slug}: ${verdict.reason}`);\n    opts.onWarn?.(\"active preset sync skipped\", { slug, reason: verdict.reason, destSlugDir });\n    return;\n  }\n  const stats = syncDirTreeDiff(srcSlugDir, destSlugDir, backupExt);\n  if (stats.updated > 0) {\n    result.updated.push(slug);\n    opts.onInfo?.(\"active preset skill updated from source\", { slug, files: stats.updated, backupSuffix: backupExt });\n  } else if (stats.skipped === 0) {\n    result.unchanged.push(slug);\n  }\n  if (stats.skipped > 0) {\n    result.skipped.push(`${slug}: ${stats.skipped} file(s) skipped`);\n    opts.onWarn?.(\"active preset skill partial update\", { slug, skipped: stats.skipped });\n  }\n}\n\n/** Realpath targets of active symlinks. Used so the prune below never\n *  deletes a directory that's serving as a symlink target (e.g. a\n *  git-managed checkout the user symlinks an active slug to). */\nfunction collectSymlinkTargets(activeDir: string, entries: readonly string[]): Set<string> {\n  const targets = new Set<string>();\n  for (const slug of entries) {\n    const entryPath = path.join(activeDir, slug);\n    try {\n      if (lstatSync(entryPath).isSymbolicLink()) targets.add(realpathSync(entryPath));\n    } catch {\n      /* unreadable — ignore */\n    }\n  }\n  return targets;\n}\n\n/** True iff the active `slug` is a retired preset safe to delete: an\n *  `mc-*` real directory inside `activeDir`, with no source preset, and\n *  not itself a symlink or a symlink target. */\nfunction isRetiredActiveSlug(slug: string, activeDir: string, sourceSlugs: ReadonlySet<string>, symlinkTargets: ReadonlySet<string>): boolean {\n  if (!isPresetSlug(slug) || sourceSlugs.has(slug)) return false;\n  const destSlugDir = path.join(activeDir, slug);\n  let info;\n  try {\n    info = lstatSync(destSlugDir);\n  } catch {\n    return false;\n  }\n  if (info.isSymbolicLink() || !info.isDirectory()) return false;\n  if (!isRealpathInside(destSlugDir, activeDir)) return false;\n  try {\n    return !symlinkTargets.has(realpathSync(destSlugDir));\n  } catch {\n    return false;\n  }\n}\n\n/** Prune active `mc-*` slugs whose launcher source preset no longer\n *  exists (a retired preset). Without this, an upgraded workspace that\n *  had starred a since-removed preset (e.g. `mc-manage-sources`) keeps\n *  the active copy forever — Claude would still discover a skill whose\n *  backend was deleted. Bounded to `mc-*` real directories that stay\n *  inside `activeDir` (never a symlink escape, never a user skill). */\nfunction removeRetiredActivePresets(opts: SyncActivePresetSkillsOptions, result: SyncActivePresetSkillsResult, sourceSlugs: ReadonlySet<string>): void {\n  let activeEntries: string[];\n  try {\n    activeEntries = readdirSync(opts.activeDir);\n  } catch {\n    return; // no active dir yet → nothing to prune\n  }\n  const symlinkTargets = collectSymlinkTargets(opts.activeDir, activeEntries);\n  for (const slug of activeEntries) {\n    if (!isRetiredActiveSlug(slug, opts.activeDir, sourceSlugs, symlinkTargets)) continue;\n    try {\n      rmSync(path.join(opts.activeDir, slug), { recursive: true, force: true });\n      result.removed.push(slug);\n      opts.onInfo?.(\"removed retired active preset skill\", { slug });\n    } catch (err) {\n      result.skipped.push(`${slug}: prune failed: ${errorMessage(err)}`);\n      opts.onWarn?.(\"active preset prune failed\", { slug, reason: errorMessage(err) });\n    }\n  }\n}\n\n/** Refresh every already-starred `mc-*` preset's active copy in\n *  `<workspaceRoot>/.claude/skills/<slug>/` to match the source.\n *  Per-file diff with `.bak.<timestamp>` backup on overwrite. Slugs\n *  that aren't starred yet are listed in `notActive` but never\n *  auto-created. */\nexport function syncActivePresetSkills(opts: SyncActivePresetSkillsOptions): SyncActivePresetSkillsResult {\n  const result: SyncActivePresetSkillsResult = { updated: [], unchanged: [], notActive: [], removed: [], skipped: [], backupSuffix: null };\n  if (!existsSync(opts.sourceDir)) return result;\n  let sourceInfo;\n  try {\n    sourceInfo = statSync(opts.sourceDir);\n  } catch (err) {\n    return abortActiveSync(opts, result, `source path stat failed: ${errorMessage(err)}`);\n  }\n  if (!sourceInfo.isDirectory()) {\n    return abortActiveSync(opts, result, \"source path exists as a non-directory; active preset sync skipped\");\n  }\n  let sourceEntries: string[];\n  try {\n    sourceEntries = readdirSync(opts.sourceDir);\n  } catch (err) {\n    return abortActiveSync(opts, result, `source readdir failed: ${errorMessage(err)}`);\n  }\n  // Single timestamp per run so a multi-file update produces sibling\n  // backups with a matching suffix — easier to grep / restore.\n  const backupExt = `.bak.${Date.now()}`;\n  result.backupSuffix = backupExt;\n  const sourceSlugs = new Set<string>();\n  for (const slug of sourceEntries) {\n    if (slug.startsWith(\".\")) continue;\n    if (!isPresetSlug(slug)) continue;\n    sourceSlugs.add(slug);\n    processActiveSlug(slug, opts, result, backupExt);\n  }\n  // Prune active copies of presets the launcher no longer ships.\n  removeRetiredActivePresets(opts, result, sourceSlugs);\n  if (result.updated.length > 0 || result.removed.length > 0) {\n    opts.onInfo?.(\"active preset skills synced\", {\n      updated: result.updated.length,\n      unchanged: result.unchanged.length,\n      notActive: result.notActive.length,\n      removed: result.removed.length,\n      skipped: result.skipped.length,\n      backupSuffix: backupExt,\n    });\n  }\n  return result;\n}\n","// Resolve the package's BUNDLED assets (shipped via package.json `files`) and seed\n// them into a workspace. ESM-only: `import.meta.url` points at this module under\n// `dist/workspace-setup/`, so `../../assets` is the package's assets dir at the\n// package root. (The workspace-setup entries build ESM only — `import.meta.url`\n// isn't available under CJS; both hosts run the server as ESM via tsx.)\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { copyFileSync, mkdirSync, readdirSync } from \"node:fs\";\n\nconst ASSETS_DIR = fileURLToPath(new URL(\"../../assets\", import.meta.url));\n\n/** The bundled help-docs source dir (`assets/helps/`). */\nexport function helpsAssetDir(): string {\n  return path.join(ASSETS_DIR, \"helps\");\n}\n\n/** The bundled preset-skills source dir (`assets/skills-preset/`) — pass as the\n *  `sourceDir` of `syncPresetSkills` / `syncActivePresetSkills`. */\nexport function presetSkillsAssetDir(): string {\n  return path.join(ASSETS_DIR, \"skills-preset\");\n}\n\n/** Copy every bundled help doc into `destDir` (created if missing). Idempotent —\n *  overwrites on each call so the help docs always track the package's version. */\nexport function seedHelps(opts: { destDir: string }): void {\n  mkdirSync(opts.destDir, { recursive: true });\n  const src = helpsAssetDir();\n  for (const file of readdirSync(src)) {\n    copyFileSync(path.join(src, file), path.join(opts.destDir, file));\n  }\n}\n"],"mappings":"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"}

package/dist/workspace-setup/slug.d.ts

@@ -0,0 +1,6 @@
+/** Launcher preset namespace. Preset skills (and only those) are `mc-*`. */
+export declare const PRESET_SLUG_PREFIX = "mc-";
+/** True for a launcher-managed preset slug (`mc-<something>`). The sync logic uses
+ *  this to bound which active skills it may refresh/prune, so user-authored skills are
+ *  never touched. */
+export declare function isPresetSlug(slug: string): boolean;

package/dist/workspace-setup/slug.js

@@ -0,0 +1,13 @@
+//#region src/workspace-setup/slug.ts
+/** Launcher preset namespace. Preset skills (and only those) are `mc-*`. */
+var PRESET_SLUG_PREFIX = "mc-";
+/** True for a launcher-managed preset slug (`mc-<something>`). The sync logic uses
+*  this to bound which active skills it may refresh/prune, so user-authored skills are
+*  never touched. */
+function isPresetSlug(slug) {
+	return slug.startsWith("mc-") && slug.length > 3;
+}
+//#endregion
+export { PRESET_SLUG_PREFIX, isPresetSlug };
+
+//# sourceMappingURL=slug.js.map

package/dist/workspace-setup/slug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.js","names":[],"sources":["../../src/workspace-setup/slug.ts"],"sourcesContent":["// Preset-skill namespace — the ONE definition of \"is this a launcher-managed preset\n// skill\". Browser-safe (no node imports) so the Vue UI can import it via the package's\n// `./slug` entry while the server-only sync logic (`.` entry, uses node:fs) imports it\n// here too. Shared by MulmoClaude and MulmoTerminal so the `mc-` convention can't drift.\n\n/** Launcher preset namespace. Preset skills (and only those) are `mc-*`. */\nexport const PRESET_SLUG_PREFIX = \"mc-\";\n\n/** True for a launcher-managed preset slug (`mc-<something>`). The sync logic uses\n *  this to bound which active skills it may refresh/prune, so user-authored skills are\n *  never touched. */\nexport function isPresetSlug(slug: string): boolean {\n  return slug.startsWith(PRESET_SLUG_PREFIX) && slug.length > PRESET_SLUG_PREFIX.length;\n}\n"],"mappings":";;AAMA,IAAa,qBAAqB;;;;AAKlC,SAAgB,aAAa,MAAuB;CAClD,OAAO,KAAK,WAAA,KAA6B,KAAK,KAAK,SAAS;AAC9D"}