@baton-dx/cli 0.4.4 → 0.6.0

package/dist/index.mjs

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
-import { r as __toESM } from "./chunk-BbwQpWto.mjs";
-import { a as Ne, c as Ve, d as bt, f as je, g as runMain, h as defineCommand, i as Le, l as We, m as require_dist, o as R, p as Ct, r as Je, s as Re, t as findSourceRoot, u as Ze } from "./context-detection-Ddu0mj_K.mjs";
-import { $ as loadLockfile, A as resolveProfileChain, B as cloneGitSource, C as mergeSkills, D as sortProfilesByWeight, E as isLockedProfile, F as removePlacedFiles, G as getIdePlatformTargetDir, H as ensureBatonDirGitignored, I as generateLock, J as isKnownIdePlatform, K as getRegisteredIdePlatforms, L as readLock, M as placeFile, N as discoverProfilesInSourceRepo, O as mergeContentParts, P as findSourceManifest, Q as parseSource, R as writeLock, S as mergeRulesWithWarnings, T as getProfileWeight, U as removeGitignoreManagedSection, V as collectComprehensivePatterns, W as updateGitignore, X as getAllAIToolAdapters, Y as getAIToolAdaptersForKeys, Z as parseFrontmatter, _ as require_lib, a as clearIdeCache, at as getAIToolConfig, b as mergeAgentsWithWarnings, c as getDefaultGlobalSource, d as getGlobalSources, et as loadProfileManifest, f as loadGlobalConfig, g as setGlobalIdePlatforms, h as setGlobalAiTools, i as computeIntersection, it as SourceParseError, j as detectLegacyPaths, k as resolveProfileSupport, l as getGlobalAiTools, m as saveGlobalConfig, n as readProjectPreferences, nt as KEBAB_CASE_REGEX, o as detectInstalledIdes, ot as getAIToolPath, p as removeGlobalSource, q as idePlatformRegistry, r as writeProjectPreferences, rt as FileNotFoundError, s as addGlobalSource, st as getAllAIToolKeys, t as resolvePreferences, tt as loadProjectManifest, u as getGlobalIdePlatforms, v as mergeMemory, w as mergeSkillsWithWarnings, x as mergeRules, y as mergeMemoryWithWarnings, z as resolveVersion } from "./src-dY02psbw.mjs";
-import { n as detectInstalledAITools, t as clearAIToolCache } from "./ai-tool-detection-CMsBNa9e.mjs";
-import { d as esm_default } from "./esm-BagM-kVd.mjs";
+import { a as Ne, c as Ve, d as bt, f as je, g as runMain, h as defineCommand, i as Le, l as We, m as require_dist, o as R, p as Ct, r as Je, s as Re, t as findSourceRoot, u as Ze, y as __toESM } from "./context-detection-D9yccWot.mjs";
+import { $ as isKnownIdePlatform, A as isLockedProfile, B as generateLock, C as mergeMemoryWithWarnings, D as mergeSkills, E as mergeRulesWithWarnings, F as detectLegacyPaths, G as esm_default, H as writeLock, I as placeFile, J as removeGitignoreManagedSection, K as collectComprehensivePatterns, L as discoverProfilesInSourceRepo, M as mergeContentParts, N as resolveProfileSupport, O as mergeSkillsWithWarnings, P as resolveProfileChain, Q as idePlatformRegistry, R as findSourceManifest, S as mergeMemory, T as mergeRules, U as resolveVersion, V as readLock, W as cloneGitSource, X as getIdePlatformTargetDir, Y as updateGitignore, Z as getRegisteredIdePlatforms, _ as removeGlobalSource, a as resolvePreferences, at as loadProjectManifest, b as setGlobalIdePlatforms, c as computeIntersection, ct as SourceParseError, d as addGlobalSource, dt as getAllAIToolKeys, et as getAIToolAdaptersForKeys, f as getDefaultGlobalSource, g as loadGlobalConfig, h as getGlobalSources, i as formatInstallCommand, it as loadProfileManifest, j as sortProfilesByWeight, k as getProfileWeight, l as clearIdeCache, lt as getAIToolConfig, m as getGlobalIdePlatforms, n as isUpdateAvailable, nt as parseFrontmatter, o as readProjectPreferences, ot as KEBAB_CASE_REGEX, p as getGlobalAiTools, q as ensureBatonDirGitignored, r as detectInstallMethod, rt as parseSource, s as writeProjectPreferences, st as FileNotFoundError, t as checkLatestVersion, tt as getAllAIToolAdapters, u as detectInstalledIdes, ut as getAIToolPath, v as saveGlobalConfig, w as mergeAgentsWithWarnings, x as require_lib, y as setGlobalAiTools, z as removePlacedFiles } from "./src-BVo3M5-4.mjs";
+import { n as detectInstalledAITools, t as clearAIToolCache } from "./ai-tool-detection-DMnwwNBI.mjs";
 import { access, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
 
 //#region src/commands/ai-tools/configure.ts
 const aiToolsConfigureCommand = defineCommand({
@@ -377,6 +376,120 @@ async function buildIntersection(sourceString, developerTools, cwd) {
 	return computeIntersection(developerTools, resolveProfileSupport(profileManifest, sourceManifest));
 }
 
+//#endregion
+//#region src/utils/first-run-preferences.ts
+/**
+* Format an IDE platform key into a display name.
+* Duplicated here to avoid circular dependency with ides/utils.
+*/
+function formatIdeName$2(ideKey) {
+	return {
+		vscode: "VS Code",
+		jetbrains: "JetBrains",
+		cursor: "Cursor",
+		windsurf: "Windsurf",
+		antigravity: "Antigravity",
+		zed: "Zed"
+	}[ideKey] ?? ideKey;
+}
+/**
+* Shows the first-run preferences prompt if .baton/preferences.yaml doesn't exist.
+*
+* Asks the user whether to use global config or customize AI tools and IDEs
+* for this project, then writes the preferences file.
+*
+* @param projectRoot - Absolute path to the project root
+* @param nonInteractive - If true, writes useGlobal: true silently
+* @returns true if preferences were written, false if already existed
+*/
+async function promptFirstRunPreferences(projectRoot, nonInteractive) {
+	if (await readProjectPreferences(projectRoot)) return false;
+	if (nonInteractive) {
+		await writeProjectPreferences(projectRoot, {
+			version: "1.0",
+			ai: {
+				useGlobal: true,
+				tools: []
+			},
+			ide: {
+				useGlobal: true,
+				platforms: []
+			}
+		});
+		return true;
+	}
+	const aiMode = await Je({
+		message: "How do you want to configure AI tools for this project?",
+		options: [{
+			value: "global",
+			label: "Use global config",
+			hint: "recommended"
+		}, {
+			value: "customize",
+			label: "Customize for this project"
+		}]
+	});
+	if (Ct(aiMode)) return false;
+	let aiUseGlobal = true;
+	let aiTools = [];
+	if (aiMode === "customize") {
+		const globalTools = await getGlobalAiTools();
+		const allAdapters = getAllAIToolAdapters();
+		const selected = await je({
+			message: "Select AI tools for this project:",
+			options: allAdapters.map((adapter) => ({
+				value: adapter.key,
+				label: globalTools.includes(adapter.key) ? `${adapter.name} (in global config)` : adapter.name
+			})),
+			initialValues: globalTools
+		});
+		if (Ct(selected)) return false;
+		aiUseGlobal = false;
+		aiTools = selected;
+	}
+	const ideMode = await Je({
+		message: "How do you want to configure IDE platforms for this project?",
+		options: [{
+			value: "global",
+			label: "Use global config",
+			hint: "recommended"
+		}, {
+			value: "customize",
+			label: "Customize for this project"
+		}]
+	});
+	if (Ct(ideMode)) return false;
+	let ideUseGlobal = true;
+	let idePlatforms = [];
+	if (ideMode === "customize") {
+		const globalPlatforms = await getGlobalIdePlatforms();
+		const allIdeKeys = getRegisteredIdePlatforms();
+		const selected = await je({
+			message: "Select IDE platforms for this project:",
+			options: allIdeKeys.map((ideKey) => ({
+				value: ideKey,
+				label: globalPlatforms.includes(ideKey) ? `${formatIdeName$2(ideKey)} (in global config)` : formatIdeName$2(ideKey)
+			})),
+			initialValues: globalPlatforms
+		});
+		if (Ct(selected)) return false;
+		ideUseGlobal = false;
+		idePlatforms = selected;
+	}
+	await writeProjectPreferences(projectRoot, {
+		version: "1.0",
+		ai: {
+			useGlobal: aiUseGlobal,
+			tools: aiTools
+		},
+		ide: {
+			useGlobal: ideUseGlobal,
+			platforms: idePlatforms
+		}
+	});
+	return true;
+}
+
 //#endregion
 //#region src/utils/intersection-display.ts
 /**
@@ -392,30 +505,842 @@ function displayIntersection(intersection) {
 		R.info("No tool or IDE intersection data available.");
 		return;
 	}
-	if (hasAiData) displayDimension("AI Tools", intersection.aiTools);
-	if (hasIdeData) displayDimension("IDE Platforms", intersection.idePlatforms);
-}
-/**
-* Display a single dimension (AI tools or IDE platforms) of the intersection.
-*/
-function displayDimension(label, dimension) {
-	const lines = [];
-	if (dimension.synced.length > 0) for (const item of dimension.synced) lines.push(`  \u2713 ${item}`);
-	if (dimension.unavailable.length > 0) for (const item of dimension.unavailable) lines.push(`  - ${item} (not installed)`);
-	if (dimension.unsupported.length > 0) for (const item of dimension.unsupported) lines.push(`  ~ ${item} (not supported by profile)`);
-	if (lines.length > 0) Ve(lines.join("\n"), label);
-}
-/**
-* Format a compact intersection summary for inline display.
-* Example: "claude-code, cursor (AI) + vscode (IDE)"
-*/
-function formatIntersectionSummary(intersection) {
-	const parts = [];
-	if (intersection.aiTools.synced.length > 0) parts.push(`${intersection.aiTools.synced.join(", ")} (AI)`);
-	if (intersection.idePlatforms.synced.length > 0) parts.push(`${intersection.idePlatforms.synced.join(", ")} (IDE)`);
-	if (parts.length === 0) return "No matching tools";
-	return parts.join(" + ");
-}
+	if (hasAiData) displayDimension("AI Tools", intersection.aiTools);
+	if (hasIdeData) displayDimension("IDE Platforms", intersection.idePlatforms);
+}
+/**
+* Display a single dimension (AI tools or IDE platforms) of the intersection.
+*/
+function displayDimension(label, dimension) {
+	const lines = [];
+	if (dimension.synced.length > 0) for (const item of dimension.synced) lines.push(`  \u2713 ${item}`);
+	if (dimension.unavailable.length > 0) for (const item of dimension.unavailable) lines.push(`  - ${item} (not installed)`);
+	if (dimension.unsupported.length > 0) for (const item of dimension.unsupported) lines.push(`  ~ ${item} (not supported by profile)`);
+	if (lines.length > 0) Ve(lines.join("\n"), label);
+}
+/**
+* Format a compact intersection summary for inline display.
+* Example: "claude-code, cursor (AI) + vscode (IDE)"
+*/
+function formatIntersectionSummary(intersection) {
+	const parts = [];
+	if (intersection.aiTools.synced.length > 0) parts.push(`${intersection.aiTools.synced.join(", ")} (AI)`);
+	if (intersection.idePlatforms.synced.length > 0) parts.push(`${intersection.idePlatforms.synced.join(", ")} (IDE)`);
+	if (parts.length === 0) return "No matching tools";
+	return parts.join(" + ");
+}
+
+//#endregion
+//#region src/commands/sync-pipeline.ts
+const validCategories = [
+	"ai",
+	"files",
+	"ide"
+];
+/** Get or initialize placed files for a profile, avoiding unsafe `as` casts on Map.get(). */
+function getOrCreatePlacedFiles(map, profileName) {
+	let files = map.get(profileName);
+	if (!files) {
+		files = {};
+		map.set(profileName, files);
+	}
+	return files;
+}
+/**
+* Recursively copy all files from sourceDir to targetDir.
+* Returns the number of files written (skips identical content).
+*/
+async function copyDirectoryRecursive(sourceDir, targetDir) {
+	await mkdir(targetDir, { recursive: true });
+	const entries = await readdir(sourceDir, { withFileTypes: true });
+	let placed = 0;
+	for (const entry of entries) {
+		const sourcePath = resolve(sourceDir, entry.name);
+		const targetPath = resolve(targetDir, entry.name);
+		if (entry.isDirectory()) placed += await copyDirectoryRecursive(sourcePath, targetPath);
+		else {
+			const content = await readFile(sourcePath, "utf-8");
+			if (await readFile(targetPath, "utf-8").catch(() => void 0) !== content) {
+				await writeFile(targetPath, content, "utf-8");
+				placed++;
+			}
+		}
+	}
+	return placed;
+}
+/**
+* Handle .gitignore update based on the project manifest's gitignore setting.
+*
+* When gitignore is enabled (default): writes comprehensive patterns for ALL
+* known AI tools and IDE platforms to ensure stable, dev-independent content.
+* When disabled: removes any existing managed section.
+* Always ensures .baton/ is gitignored regardless of setting.
+*/
+async function handleGitignoreUpdate(params) {
+	const { projectManifest, fileMap, projectRoot, spinner } = params;
+	const gitignoreEnabled = projectManifest.gitignore !== false;
+	await ensureBatonDirGitignored(projectRoot);
+	if (gitignoreEnabled) {
+		spinner.start("Updating .gitignore...");
+		const updated = await updateGitignore(projectRoot, collectComprehensivePatterns({ fileTargets: [...fileMap.values()].map((f) => f.target) }));
+		spinner.stop(updated ? "Updated .gitignore with managed patterns" : ".gitignore already up to date");
+	} else {
+		spinner.start("Checking .gitignore...");
+		const removed = await removeGitignoreManagedSection(projectRoot);
+		spinner.stop(removed ? "Removed managed section from .gitignore" : ".gitignore unchanged");
+	}
+}
+/**
+* Generate and write the baton.lock lockfile from placed files and profile metadata.
+*/
+async function writeLockData(params) {
+	const { allProfiles, sourceShas, placedFiles, projectRoot, spinner } = params;
+	spinner.start("Updating lockfile...");
+	const lockPackages = {};
+	for (const profile of allProfiles) lockPackages[profile.name] = {
+		source: profile.source,
+		resolved: profile.source,
+		version: profile.manifest.version,
+		sha: sourceShas.get(profile.source) || "unknown",
+		files: placedFiles.get(profile.name) || {}
+	};
+	await writeLock(generateLock(lockPackages), resolve(projectRoot, "baton.lock"));
+	spinner.stop("Lockfile updated");
+}
+/**
+* Detect and remove files that were in the previous lockfile but are no longer
+* part of the current sync. Cleans up empty parent directories.
+*/
+async function cleanupOrphanedFiles(params) {
+	const { previousPaths, placedFiles, projectRoot, dryRun, autoYes, spinner } = params;
+	if (previousPaths.size === 0) return;
+	const currentPaths = /* @__PURE__ */ new Set();
+	for (const files of placedFiles.values()) for (const filePath of Object.keys(files)) currentPaths.add(filePath);
+	const orphanedPaths = [...previousPaths].filter((prev) => !currentPaths.has(prev));
+	if (orphanedPaths.length === 0) return;
+	if (dryRun) {
+		R.warn(`Would remove ${orphanedPaths.length} orphaned file(s):`);
+		for (const orphanedPath of orphanedPaths) R.info(`  Removed: ${orphanedPath}`);
+		return;
+	}
+	R.warn(`Found ${orphanedPaths.length} orphaned file(s) to remove:`);
+	for (const orphanedPath of orphanedPaths) R.info(`  Removed: ${orphanedPath}`);
+	let shouldRemove = autoYes;
+	if (!autoYes) {
+		const confirmed = await Re({
+			message: `Remove ${orphanedPaths.length} orphaned file(s)?`,
+			initialValue: true
+		});
+		if (Ct(confirmed)) {
+			R.info("Skipped orphan removal.");
+			shouldRemove = false;
+		} else shouldRemove = confirmed;
+	}
+	if (!shouldRemove) {
+		R.info("Orphan removal skipped.");
+		return;
+	}
+	spinner.start("Removing orphaned files...");
+	const removedCount = await removePlacedFiles(orphanedPaths, projectRoot);
+	spinner.stop(`Removed ${removedCount} orphaned file(s)`);
+}
+
+//#endregion
+//#region src/commands/apply.ts
+/** Extract the package name from a source string for lockfile lookup. */
+function getPackageNameFromSource(source, parsed) {
+	if (parsed.provider === "github" || parsed.provider === "gitlab") return `${parsed.org}/${parsed.repo}`;
+	if (parsed.provider === "npm") return parsed.scope ? `${parsed.scope}/${parsed.package}` : parsed.package;
+	if (parsed.provider === "git") return parsed.url;
+	return source;
+}
+const applyCommand = defineCommand({
+	meta: {
+		name: "apply",
+		description: "Apply locked configurations to the project (deterministic, reproducible)"
+	},
+	args: {
+		"dry-run": {
+			type: "boolean",
+			description: "Show what would be done without writing files",
+			default: false
+		},
+		category: {
+			type: "string",
+			description: "Apply only a specific category: ai, files, or ide",
+			required: false
+		},
+		yes: {
+			type: "boolean",
+			description: "Run non-interactively (no prompts)",
+			default: false
+		},
+		verbose: {
+			type: "boolean",
+			alias: "v",
+			description: "Show detailed output for each placed file",
+			default: false
+		},
+		fresh: {
+			type: "boolean",
+			description: "Force cache bypass (re-clone even if cached)",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const dryRun = args["dry-run"];
+		const categoryArg = args.category;
+		const autoYes = args.yes;
+		const verbose = args.verbose;
+		const fresh = args.fresh;
+		let category;
+		if (categoryArg) {
+			if (!validCategories.includes(categoryArg)) {
+				Ne(`Invalid category "${categoryArg}". Valid categories: ${validCategories.join(", ")}`);
+				process.exit(1);
+			}
+			category = categoryArg;
+		}
+		const syncAi = !category || category === "ai";
+		const syncFiles = !category || category === "files";
+		const syncIde = !category || category === "ide";
+		We(category ? `📦 Baton Apply (category: ${category})` : "📦 Baton Apply");
+		const stats = {
+			created: 0,
+			errors: 0
+		};
+		try {
+			const projectRoot = process.cwd();
+			const manifestPath = resolve(projectRoot, "baton.yaml");
+			let projectManifest;
+			try {
+				projectManifest = await loadProjectManifest(manifestPath);
+			} catch (error) {
+				if (error instanceof FileNotFoundError) Ne("baton.yaml not found. Run `baton init` first.");
+				else Ne(`Failed to load baton.yaml: ${error instanceof Error ? error.message : String(error)}`);
+				process.exit(1);
+			}
+			await promptFirstRunPreferences(projectRoot, !!args.yes);
+			const lockfilePath = resolve(projectRoot, "baton.lock");
+			let lockfile = null;
+			try {
+				lockfile = await readLock(lockfilePath);
+			} catch {
+				if (verbose) R.warn("No lockfile found. Falling back to manifest versions.");
+			}
+			const maxCacheAgeMs = fresh ? 0 : void 0;
+			const previousPaths = /* @__PURE__ */ new Set();
+			if (lockfile) for (const pkg of Object.values(lockfile.packages)) for (const filePath of Object.keys(pkg.integrity)) previousPaths.add(filePath);
+			const spinner = bt();
+			spinner.start("Resolving profile chain...");
+			const allProfiles = [];
+			const sourceShas = /* @__PURE__ */ new Map();
+			for (const profileSource of projectManifest.profiles || []) try {
+				if (verbose) R.info(`Resolving source: ${profileSource.source}`);
+				const parsed = parseSource(profileSource.source);
+				let manifestPath;
+				let cloneContext;
+				if (parsed.provider === "local" || parsed.provider === "file") {
+					const absolutePath = parsed.path.startsWith("/") ? parsed.path : resolve(projectRoot, parsed.path);
+					manifestPath = resolve(absolutePath, "baton.profile.yaml");
+					try {
+						const git = esm_default(absolutePath);
+						await git.checkIsRepo();
+						const sha = await git.revparse(["HEAD"]);
+						sourceShas.set(profileSource.source, sha.trim());
+					} catch {
+						sourceShas.set(profileSource.source, "local");
+					}
+				} else {
+					const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
+					if (!url) throw new Error(`Invalid source: ${profileSource.source}`);
+					let ref = profileSource.version;
+					if (lockfile) {
+						const packageName = getPackageNameFromSource(profileSource.source, parsed);
+						const lockedPkg = lockfile.packages[packageName];
+						if (lockedPkg?.sha && lockedPkg.sha !== "unknown") {
+							ref = lockedPkg.sha;
+							if (verbose) R.info(`Using locked SHA for ${profileSource.source}: ${ref.slice(0, 12)}`);
+						}
+					}
+					const cloned = await cloneGitSource({
+						url,
+						ref,
+						subpath: "subpath" in parsed ? parsed.subpath : void 0,
+						useCache: true,
+						maxCacheAgeMs
+					});
+					manifestPath = resolve(cloned.localPath, "baton.profile.yaml");
+					sourceShas.set(profileSource.source, cloned.sha);
+					cloneContext = {
+						cachePath: cloned.cachePath,
+						sparseCheckout: cloned.sparseCheckout
+					};
+				}
+				const manifest = await loadProfileManifest(manifestPath);
+				const profileDir = dirname(manifestPath);
+				const chain = await resolveProfileChain(manifest, profileSource.source, profileDir, cloneContext);
+				allProfiles.push(...chain);
+			} catch (error) {
+				spinner.stop(`Failed to resolve profile ${profileSource.source}: ${error}`);
+				stats.errors++;
+			}
+			if (allProfiles.length === 0) {
+				spinner.stop("No profiles configured");
+				Le("Nothing to apply. Run `baton manage` to add a profile.");
+				process.exit(2);
+			}
+			spinner.stop(`Resolved ${allProfiles.length} profile(s)`);
+			const weightSortedProfiles = sortProfilesByWeight(allProfiles);
+			spinner.start("Merging configurations...");
+			const allWeightWarnings = [];
+			const skillsResult = mergeSkillsWithWarnings(weightSortedProfiles);
+			const mergedSkills = skillsResult.skills;
+			allWeightWarnings.push(...skillsResult.warnings);
+			const rulesResult = mergeRulesWithWarnings(weightSortedProfiles);
+			const mergedRules = rulesResult.rules;
+			allWeightWarnings.push(...rulesResult.warnings);
+			const agentsResult = mergeAgentsWithWarnings(weightSortedProfiles);
+			const mergedAgents = agentsResult.agents;
+			allWeightWarnings.push(...agentsResult.warnings);
+			const memoryResult = mergeMemoryWithWarnings(weightSortedProfiles);
+			const mergedMemory = memoryResult.entries;
+			allWeightWarnings.push(...memoryResult.warnings);
+			const commandMap = /* @__PURE__ */ new Map();
+			const lockedCommands = /* @__PURE__ */ new Set();
+			const commandOwner = /* @__PURE__ */ new Map();
+			for (const profile of weightSortedProfiles) {
+				const weight = getProfileWeight(profile);
+				const locked = isLockedProfile(profile);
+				for (const cmd of profile.manifest.ai?.commands || []) {
+					if (lockedCommands.has(cmd)) continue;
+					const existing = commandOwner.get(cmd);
+					if (existing && existing.weight === weight && existing.profileName !== profile.name) allWeightWarnings.push({
+						key: cmd,
+						category: "command",
+						profileA: existing.profileName,
+						profileB: profile.name,
+						weight
+					});
+					commandMap.set(cmd, profile.name);
+					commandOwner.set(cmd, {
+						profileName: profile.name,
+						weight
+					});
+					if (locked) lockedCommands.add(cmd);
+				}
+			}
+			const mergedCommandCount = commandMap.size;
+			const fileMap = /* @__PURE__ */ new Map();
+			const lockedFiles = /* @__PURE__ */ new Set();
+			const fileOwner = /* @__PURE__ */ new Map();
+			for (const profile of weightSortedProfiles) {
+				const weight = getProfileWeight(profile);
+				const locked = isLockedProfile(profile);
+				for (const fileConfig of profile.manifest.files || []) {
+					const target = fileConfig.target || fileConfig.source;
+					if (lockedFiles.has(target)) continue;
+					const existing = fileOwner.get(target);
+					if (existing && existing.weight === weight && existing.profileName !== profile.name) allWeightWarnings.push({
+						key: target,
+						category: "file",
+						profileA: existing.profileName,
+						profileB: profile.name,
+						weight
+					});
+					fileMap.set(target, {
+						source: fileConfig.source,
+						target,
+						profileName: profile.name
+					});
+					fileOwner.set(target, {
+						profileName: profile.name,
+						weight
+					});
+					if (locked) lockedFiles.add(target);
+				}
+			}
+			const mergedFileCount = fileMap.size;
+			const ideMap = /* @__PURE__ */ new Map();
+			const lockedIdeConfigs = /* @__PURE__ */ new Set();
+			const ideOwner = /* @__PURE__ */ new Map();
+			for (const profile of weightSortedProfiles) {
+				if (!profile.manifest.ide) continue;
+				const weight = getProfileWeight(profile);
+				const locked = isLockedProfile(profile);
+				for (const [ideKey, files] of Object.entries(profile.manifest.ide)) {
+					if (!files) continue;
+					const targetDir = getIdePlatformTargetDir(ideKey);
+					if (!targetDir) {
+						if (!isKnownIdePlatform(ideKey)) R.warn(`Unknown IDE platform "${ideKey}" in profile "${profile.name}" — skipping. Register it in the IDE platform registry.`);
+						continue;
+					}
+					for (const fileName of files) {
+						const targetPath = `${targetDir}/${fileName}`;
+						if (lockedIdeConfigs.has(targetPath)) continue;
+						const existing = ideOwner.get(targetPath);
+						if (existing && existing.weight === weight && existing.profileName !== profile.name) allWeightWarnings.push({
+							key: targetPath,
+							category: "ide",
+							profileA: existing.profileName,
+							profileB: profile.name,
+							weight
+						});
+						ideMap.set(targetPath, {
+							ideKey,
+							fileName,
+							targetDir,
+							profileName: profile.name
+						});
+						ideOwner.set(targetPath, {
+							profileName: profile.name,
+							weight
+						});
+						if (locked) lockedIdeConfigs.add(targetPath);
+					}
+				}
+			}
+			const mergedIdeCount = ideMap.size;
+			spinner.stop(`Merged: ${mergedSkills.length} skills, ${mergedRules.length} rules, ${mergedAgents.length} agents, ${mergedMemory.length} memory files, ${mergedCommandCount} commands, ${mergedFileCount} files, ${mergedIdeCount} IDE configs`);
+			if (allWeightWarnings.length > 0) for (const w of allWeightWarnings) R.warn(`Weight conflict: "${w.profileA}" and "${w.profileB}" both define ${w.category} "${w.key}" with weight ${w.weight}. Last declared wins.`);
+			spinner.start("Computing tool intersection...");
+			const prefs = await resolvePreferences(projectRoot);
+			const detectedAITools = await detectInstalledAITools();
+			if (verbose) {
+				R.info(`AI tools: ${prefs.ai.tools.join(", ") || "(none)"} (from ${prefs.ai.source} preferences)`);
+				R.info(`IDE platforms: ${prefs.ide.platforms.join(", ") || "(none)"} (from ${prefs.ide.source} preferences)`);
+			}
+			let syncedAiTools;
+			let syncedIdePlatforms = null;
+			let allIntersections = null;
+			if (prefs.ai.tools.length > 0) {
+				const developerTools = {
+					aiTools: prefs.ai.tools,
+					idePlatforms: prefs.ide.platforms
+				};
+				const aggregatedSyncedAi = /* @__PURE__ */ new Set();
+				const aggregatedSyncedIde = /* @__PURE__ */ new Set();
+				allIntersections = /* @__PURE__ */ new Map();
+				for (const profileSource of projectManifest.profiles || []) try {
+					const intersection = await buildIntersection(profileSource.source, developerTools, projectRoot);
+					if (intersection) {
+						allIntersections.set(profileSource.source, intersection);
+						for (const tool of intersection.aiTools.synced) aggregatedSyncedAi.add(tool);
+						for (const platform of intersection.idePlatforms.synced) aggregatedSyncedIde.add(platform);
+					}
+				} catch {}
+				syncedAiTools = aggregatedSyncedAi.size > 0 ? [...aggregatedSyncedAi] : [];
+				syncedIdePlatforms = [...aggregatedSyncedIde];
+			} else {
+				syncedAiTools = detectedAITools;
+				syncedIdePlatforms = null;
+				if (detectedAITools.length > 0) {
+					R.warn("No AI tools configured. Run `baton ai-tools scan` to configure your tools.");
+					R.info(`Falling back to detected tools: ${detectedAITools.join(", ")}`);
+				}
+			}
+			if (syncedAiTools.length === 0 && detectedAITools.length === 0) {
+				spinner.stop("No AI tools available");
+				Ne("No AI tools found. Install an AI coding tool first.");
+				process.exit(1);
+			}
+			if (syncedAiTools.length === 0) {
+				spinner.stop("No AI tools in intersection");
+				Ne("No AI tools match between your configuration and profile support. Run `baton ai-tools scan` or check your profile's supported tools.");
+				process.exit(1);
+			}
+			if (allIntersections) for (const [source, intersection] of allIntersections) if (verbose) {
+				R.step(`Intersection for ${source}`);
+				displayIntersection(intersection);
+			} else {
+				const summary = formatIntersectionSummary(intersection);
+				R.info(`Applying for: ${summary}`);
+			}
+			const ideSummary = syncedIdePlatforms && syncedIdePlatforms.length > 0 ? ` | IDE platforms: ${syncedIdePlatforms.join(", ")}` : "";
+			spinner.stop(`Applying to AI tools: ${syncedAiTools.join(", ")}${ideSummary}`);
+			spinner.start("Checking for legacy paths...");
+			const legacyFiles = await detectLegacyPaths(projectRoot);
+			if (legacyFiles.length > 0 && !dryRun) {
+				spinner.stop(`Found ${legacyFiles.length} legacy file(s)`);
+				if (!autoYes) {
+					Ve(`Found legacy configuration files:\n${legacyFiles.map((f) => `  - ${f.legacyPath}`).join("\n")}`, "Legacy Files");
+					R.warn("Run migration manually with appropriate action (migrate/copy/skip)");
+				}
+			} else spinner.stop("No legacy files found");
+			spinner.start("Processing configurations...");
+			const adapters = getAIToolAdaptersForKeys(syncedAiTools);
+			const placementConfig = {
+				mode: "copy",
+				projectRoot
+			};
+			const placedFiles = /* @__PURE__ */ new Map();
+			const profileLocalPaths = /* @__PURE__ */ new Map();
+			for (const profileSource of projectManifest.profiles || []) {
+				const parsed = parseSource(profileSource.source);
+				if (parsed.provider === "local" || parsed.provider === "file") {
+					const localPath = parsed.path.startsWith("/") ? parsed.path : resolve(projectRoot, parsed.path);
+					for (const prof of allProfiles) if (prof.source === profileSource.source) profileLocalPaths.set(prof.name, localPath);
+				} else if (parsed.provider === "github" || parsed.provider === "gitlab" || parsed.provider === "git") {
+					const url = parsed.provider === "git" ? parsed.url : parsed.url;
+					let ref = profileSource.version;
+					if (lockfile) {
+						const packageName = getPackageNameFromSource(profileSource.source, parsed);
+						const lockedPkg = lockfile.packages[packageName];
+						if (lockedPkg?.sha && lockedPkg.sha !== "unknown") ref = lockedPkg.sha;
+					}
+					const cloned = await cloneGitSource({
+						url,
+						ref,
+						subpath: "subpath" in parsed ? parsed.subpath : void 0,
+						useCache: true,
+						maxCacheAgeMs
+					});
+					for (const prof of allProfiles) if (prof.source === profileSource.source) profileLocalPaths.set(prof.name, cloned.localPath);
+				}
+			}
+			for (const prof of allProfiles) if (!profileLocalPaths.has(prof.name) && prof.localPath) profileLocalPaths.set(prof.name, prof.localPath);
+			const contentAccumulator = /* @__PURE__ */ new Map();
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) R.step(`[${adapter.key}] Placing memory files...`);
+				for (const memoryEntry of mergedMemory) try {
+					const contentParts = [];
+					for (const contribution of memoryEntry.contributions) {
+						const profileDir = profileLocalPaths.get(contribution.profileName);
+						if (!profileDir) {
+							spinner.message(`Warning: Could not resolve local path for profile ${contribution.profileName}`);
+							continue;
+						}
+						const memoryFilePath = resolve(profileDir, "ai", "memory", memoryEntry.filename);
+						try {
+							const content = await readFile(memoryFilePath, "utf-8");
+							contentParts.push(content);
+						} catch {
+							spinner.message(`Warning: Could not read ${memoryFilePath}`);
+						}
+					}
+					if (contentParts.length === 0) continue;
+					const mergedContent = mergeContentParts(contentParts, memoryEntry.mergeStrategy);
+					const transformed = adapter.transformMemory({
+						filename: memoryEntry.filename,
+						content: mergedContent
+					});
+					const targetPath = adapter.getPath("memory", "project", transformed.filename);
+					const absolutePath = targetPath.startsWith("/") ? targetPath : resolve(projectRoot, targetPath);
+					const existing = contentAccumulator.get(absolutePath);
+					if (existing) {
+						existing.parts.push(transformed.content);
+						for (const c of memoryEntry.contributions) existing.profiles.add(c.profileName);
+					} else {
+						const profiles = /* @__PURE__ */ new Set();
+						for (const c of memoryEntry.contributions) profiles.add(c.profileName);
+						contentAccumulator.set(absolutePath, {
+							parts: [transformed.content],
+							adapter,
+							type: "memory",
+							name: transformed.filename,
+							profiles
+						});
+					}
+				} catch (error) {
+					spinner.message(`Error placing ${memoryEntry.filename} for ${adapter.name}: ${error}`);
+					stats.errors++;
+				}
+			}
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) R.step(`[${adapter.key}] Placing skills...`);
+				for (const skillItem of mergedSkills) try {
+					const profileDir = profileLocalPaths.get(skillItem.profileName);
+					if (!profileDir) {
+						spinner.message(`Warning: Could not resolve local path for profile ${skillItem.profileName}`);
+						continue;
+					}
+					const skillSourceDir = resolve(profileDir, "ai", "skills", skillItem.name);
+					try {
+						await stat(skillSourceDir);
+					} catch {
+						spinner.message(`Warning: Skill directory not found: ${skillSourceDir}`);
+						continue;
+					}
+					const targetSkillPath = adapter.getPath("skills", skillItem.scope, skillItem.name);
+					const absoluteTargetDir = targetSkillPath.startsWith("/") ? targetSkillPath : resolve(projectRoot, targetSkillPath);
+					const placed = await copyDirectoryRecursive(skillSourceDir, absoluteTargetDir);
+					stats.created += placed;
+					const profileFiles = getOrCreatePlacedFiles(placedFiles, skillItem.profileName);
+					try {
+						profileFiles[targetSkillPath] = {
+							content: await readFile(resolve(skillSourceDir, "index.md"), "utf-8"),
+							tool: adapter.key,
+							category: "ai"
+						};
+					} catch {
+						profileFiles[targetSkillPath] = {
+							content: skillItem.name,
+							tool: adapter.key,
+							category: "ai"
+						};
+					}
+					if (verbose) {
+						const label = placed > 0 ? `${placed} file(s) created` : "unchanged, skipped";
+						R.info(`  -> ${absoluteTargetDir}/ (${label})`);
+					}
+				} catch (error) {
+					spinner.message(`Error placing skill ${skillItem.name} for ${adapter.name}: ${error}`);
+					stats.errors++;
+				}
+			}
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) R.step(`[${adapter.key}] Placing rules...`);
+				for (const ruleEntry of mergedRules) try {
+					const ruleName = ruleEntry.name.replace(/\.md$/, "");
+					const isUniversal = ruleEntry.agents.length === 0;
+					const isForThisAdapter = ruleEntry.agents.includes(adapter.key);
+					if (!isUniversal && !isForThisAdapter) continue;
+					const profileDir = profileLocalPaths.get(ruleEntry.profileName);
+					if (!profileDir) {
+						spinner.message(`Warning: Could not resolve local path for profile ${ruleEntry.profileName}`);
+						continue;
+					}
+					const ruleSourcePath = resolve(profileDir, "ai", "rules", isUniversal ? "universal" : ruleEntry.agents[0], `${ruleName}.md`);
+					let rawContent;
+					try {
+						rawContent = await readFile(ruleSourcePath, "utf-8");
+					} catch {
+						spinner.message(`Warning: Could not read rule file: ${ruleSourcePath}`);
+						continue;
+					}
+					const parsed = parseFrontmatter(rawContent);
+					const ruleFile = {
+						name: ruleName,
+						content: rawContent,
+						frontmatter: Object.keys(parsed.data).length > 0 ? parsed.data : void 0
+					};
+					const transformed = adapter.transformRule(ruleFile);
+					const targetPath = adapter.getPath("rules", "project", ruleName);
+					const absolutePath = targetPath.startsWith("/") ? targetPath : resolve(projectRoot, targetPath);
+					const existing = contentAccumulator.get(absolutePath);
+					if (existing) {
+						existing.parts.push(transformed.content);
+						existing.profiles.add(ruleEntry.profileName);
+					} else contentAccumulator.set(absolutePath, {
+						parts: [transformed.content],
+						adapter,
+						type: "rules",
+						name: ruleName,
+						profiles: new Set([ruleEntry.profileName])
+					});
+				} catch (error) {
+					spinner.message(`Error placing rule ${ruleEntry.name} for ${adapter.name}: ${error}`);
+					stats.errors++;
+				}
+			}
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) R.step(`[${adapter.key}] Placing agents...`);
+				for (const agentEntry of mergedAgents) try {
+					const agentName = agentEntry.name.replace(/\.md$/, "");
+					const isUniversal = agentEntry.agents.length === 0;
+					const isForThisAdapter = agentEntry.agents.includes(adapter.key);
+					if (!isUniversal && !isForThisAdapter) continue;
+					const profileDir = profileLocalPaths.get(agentEntry.profileName);
+					if (!profileDir) {
+						spinner.message(`Warning: Could not resolve local path for profile ${agentEntry.profileName}`);
+						continue;
+					}
+					const agentSourcePath = resolve(profileDir, "ai", "agents", isUniversal ? "universal" : agentEntry.agents[0], `${agentName}.md`);
+					let rawContent;
+					try {
+						rawContent = await readFile(agentSourcePath, "utf-8");
+					} catch {
+						spinner.message(`Warning: Could not read agent file: ${agentSourcePath}`);
+						continue;
+					}
+					const parsed = parseFrontmatter(rawContent);
+					const frontmatter = Object.keys(parsed.data).length > 0 ? parsed.data : { name: agentName };
+					const agentFile = {
+						name: agentName,
+						content: rawContent,
+						description: frontmatter.description,
+						frontmatter
+					};
+					const transformed = adapter.transformAgent(agentFile);
+					const targetPath = adapter.getPath("agents", "project", agentName);
+					const absolutePath = targetPath.startsWith("/") ? targetPath : resolve(projectRoot, targetPath);
+					const existing = contentAccumulator.get(absolutePath);
+					if (existing) {
+						existing.parts.push(transformed.content);
+						existing.profiles.add(agentEntry.profileName);
+					} else contentAccumulator.set(absolutePath, {
+						parts: [transformed.content],
+						adapter,
+						type: "agents",
+						name: agentName,
+						profiles: new Set([agentEntry.profileName])
+					});
+				} catch (error) {
+					spinner.message(`Error placing agent ${agentEntry.name} for ${adapter.name}: ${error}`);
+					stats.errors++;
+				}
+			}
+			if (!dryRun && syncAi) for (const [absolutePath, entry] of contentAccumulator) try {
+				const combinedContent = entry.parts.join("\n\n");
+				const result = await placeFile(combinedContent, entry.adapter, entry.type, "project", entry.name, placementConfig);
+				if (result.action !== "skipped") stats.created++;
+				const relPath = isAbsolute(result.path) ? relative(projectRoot, result.path) : result.path;
+				for (const profileName of entry.profiles) {
+					const pf = getOrCreatePlacedFiles(placedFiles, profileName);
+					pf[relPath] = {
+						content: combinedContent,
+						tool: entry.adapter.key,
+						category: "ai"
+					};
+				}
+				if (verbose) {
+					const label = result.action === "skipped" ? "unchanged, skipped" : result.action;
+					R.info(`  -> ${result.path} (${label})`);
+				}
+			} catch (error) {
+				spinner.message(`Error placing accumulated content to ${absolutePath}: ${error}`);
+				stats.errors++;
+			}
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) R.step(`[${adapter.key}] Placing commands...`);
+				for (const profile of allProfiles) {
+					const profileDir = profileLocalPaths.get(profile.name);
+					if (!profileDir) continue;
+					const commandNames = profile.manifest.ai?.commands || [];
+					for (const commandName of commandNames) try {
+						const commandSourcePath = resolve(profileDir, "ai", "commands", `${commandName}.md`);
+						let content;
+						try {
+							content = await readFile(commandSourcePath, "utf-8");
+						} catch {
+							continue;
+						}
+						const result = await placeFile(content, adapter, "commands", "project", commandName, placementConfig);
+						if (result.action !== "skipped") stats.created++;
+						const cmdRelPath = isAbsolute(result.path) ? relative(projectRoot, result.path) : result.path;
+						const pf = getOrCreatePlacedFiles(placedFiles, profile.name);
+						pf[cmdRelPath] = {
+							content,
+							tool: adapter.key,
+							category: "ai"
+						};
+						if (verbose) {
+							const label = result.action === "skipped" ? "unchanged, skipped" : result.action;
+							R.info(`  -> ${result.path} (${label})`);
+						}
+					} catch (error) {
+						spinner.message(`Error placing command ${commandName} for ${adapter.name}: ${error}`);
+						stats.errors++;
+					}
+				}
+			}
+			if (!dryRun && syncFiles) for (const fileEntry of fileMap.values()) try {
+				const profileDir = profileLocalPaths.get(fileEntry.profileName);
+				if (!profileDir) continue;
+				const fileSourcePath = resolve(profileDir, "files", fileEntry.source);
+				let content;
+				try {
+					content = await readFile(fileSourcePath, "utf-8");
+				} catch {
+					continue;
+				}
+				const targetPath = resolve(projectRoot, fileEntry.target);
+				await mkdir(dirname(targetPath), { recursive: true });
+				if (await readFile(targetPath, "utf-8").catch(() => void 0) !== content) {
+					await writeFile(targetPath, content, "utf-8");
+					stats.created++;
+					if (verbose) R.info(`  -> ${fileEntry.target} (created)`);
+				} else if (verbose) R.info(`  -> ${fileEntry.target} (unchanged, skipped)`);
+				const fpf = getOrCreatePlacedFiles(placedFiles, fileEntry.profileName);
+				fpf[fileEntry.target] = {
+					content,
+					category: "files"
+				};
+			} catch (error) {
+				spinner.message(`Error placing file ${fileEntry.source}: ${error}`);
+				stats.errors++;
+			}
+			if (!dryRun && syncIde) for (const ideEntry of ideMap.values()) try {
+				if (syncedIdePlatforms !== null && !syncedIdePlatforms.includes(ideEntry.ideKey)) {
+					if (verbose) R.info(`  -> ${ideEntry.targetDir}/${ideEntry.fileName} (skipped — IDE platform "${ideEntry.ideKey}" not in intersection)`);
+					continue;
+				}
+				const profileDir = profileLocalPaths.get(ideEntry.profileName);
+				if (!profileDir) continue;
+				const ideSourcePath = resolve(profileDir, "ide", ideEntry.ideKey, ideEntry.fileName);
+				let content;
+				try {
+					content = await readFile(ideSourcePath, "utf-8");
+				} catch {
+					continue;
+				}
+				const targetPath = resolve(projectRoot, ideEntry.targetDir, ideEntry.fileName);
+				await mkdir(dirname(targetPath), { recursive: true });
+				if (await readFile(targetPath, "utf-8").catch(() => void 0) !== content) {
+					await writeFile(targetPath, content, "utf-8");
+					stats.created++;
+					if (verbose) R.info(`  -> ${ideEntry.targetDir}/${ideEntry.fileName} (created)`);
+				} else if (verbose) R.info(`  -> ${ideEntry.targetDir}/${ideEntry.fileName} (unchanged, skipped)`);
+				const ideRelPath = `${ideEntry.targetDir}/${ideEntry.fileName}`;
+				const ipf = getOrCreatePlacedFiles(placedFiles, ideEntry.profileName);
+				ipf[ideRelPath] = {
+					content,
+					tool: ideEntry.ideKey,
+					category: "ide"
+				};
+			} catch (error) {
+				spinner.message(`Error placing IDE config ${ideEntry.fileName}: ${error}`);
+				stats.errors++;
+			}
+			spinner.stop(dryRun ? `Would place files for ${adapters.length} agent(s)` : `Placed ${stats.created} file(s) for ${adapters.length} agent(s)`);
+			if (!dryRun) await handleGitignoreUpdate({
+				projectManifest,
+				fileMap,
+				projectRoot,
+				spinner
+			});
+			if (!dryRun) await writeLockData({
+				allProfiles,
+				sourceShas,
+				placedFiles,
+				projectRoot,
+				spinner
+			});
+			await cleanupOrphanedFiles({
+				previousPaths,
+				placedFiles,
+				projectRoot,
+				dryRun,
+				autoYes,
+				spinner
+			});
+			if (dryRun) {
+				const parts = [];
+				if (syncAi) {
+					parts.push(`  • ${mergedSkills.length} skills`);
+					parts.push(`  • ${mergedRules.length} rules`);
+					parts.push(`  • ${mergedAgents.length} agents`);
+					parts.push(`  • ${mergedMemory.length} memory files`);
+					parts.push(`  • ${mergedCommandCount} commands`);
+				}
+				if (syncFiles) parts.push(`  • ${mergedFileCount} files`);
+				if (syncIde) {
+					const filteredIdeCount = syncedIdePlatforms !== null ? [...ideMap.values()].filter((e) => syncedIdePlatforms.includes(e.ideKey)).length : mergedIdeCount;
+					parts.push(`  • ${filteredIdeCount} IDE configs`);
+				}
+				const categoryLabel = category ? ` (category: ${category})` : "";
+				Le(`[Dry Run${categoryLabel}] Would apply:\n${parts.join("\n")}\n\nFor ${adapters.length} agent(s): ${syncedAiTools.join(", ")}`);
+			} else {
+				const categoryLabel = category ? ` (category: ${category})` : "";
+				Le(`✅ Apply complete${categoryLabel}! Locked configurations applied.`);
+			}
+			process.exit(stats.errors > 0 ? 1 : 0);
+		} catch (error) {
+			Ne(`Apply failed: ${error}`);
+			process.exit(1);
+		}
+	}
+});
 
 //#endregion
 //#region src/commands/config/set.ts
@@ -943,7 +1868,7 @@ async function loadFilesFromDirectory(dirPath) {
 /**
 * Format an IDE platform key into a display name.
 */
-function formatIdeName$2(ideKey) {
+function formatIdeName$1(ideKey) {
 	return {
 		vscode: "VS Code",
 		jetbrains: "JetBrains",
@@ -989,7 +1914,7 @@ async function runGlobalMode(nonInteractive) {
 	const options = getRegisteredIdePlatforms().map((ideKey) => {
 		return {
 			value: ideKey,
-			label: currentPlatforms.includes(ideKey) ? `${formatIdeName$2(ideKey)} (currently saved)` : formatIdeName$2(ideKey)
+			label: currentPlatforms.includes(ideKey) ? `${formatIdeName$1(ideKey)} (currently saved)` : formatIdeName$1(ideKey)
 		};
 	});
 	const selected = await je({
@@ -1076,7 +2001,7 @@ async function runProjectMode(nonInteractive) {
 	const options = allIdeKeys.map((ideKey) => {
 		return {
 			value: ideKey,
-			label: globalPlatforms.includes(ideKey) ? `${formatIdeName$2(ideKey)} (in global config)` : formatIdeName$2(ideKey)
+			label: globalPlatforms.includes(ideKey) ? `${formatIdeName$1(ideKey)} (in global config)` : formatIdeName$1(ideKey)
 		};
 	});
 	const selected = await je({
@@ -1132,7 +2057,7 @@ const idesListCommand = defineCommand({
 			const entry = idePlatformRegistry[ideKey];
 			return {
 				key: ideKey,
-				name: formatIdeName$2(ideKey),
+				name: formatIdeName$1(ideKey),
 				saved: isSaved,
 				targetDir: entry?.targetDir ?? "unknown"
 			};
@@ -1148,7 +2073,7 @@ const idesListCommand = defineCommand({
 			R.info(`All ${allIdeKeys.length} supported platforms:`);
 			for (const key of allIdeKeys) {
 				const entry = idePlatformRegistry[key];
-				console.log(`  \x1b[90m- ${formatIdeName$2(key)} (${entry?.targetDir ?? key})\x1b[0m`);
+				console.log(`  \x1b[90m- ${formatIdeName$1(key)} (${entry?.targetDir ?? key})\x1b[0m`);
 			}
 			Le("Run 'baton ides scan' to get started.");
 			return;
@@ -1198,7 +2123,7 @@ const idesScanCommand = defineCommand({
 		const options = allIdeKeys.map((ideKey) => {
 			return {
 				value: ideKey,
-				label: detectedIdes.includes(ideKey) ? `${formatIdeName$2(ideKey)} (detected)` : formatIdeName$2(ideKey)
+				label: detectedIdes.includes(ideKey) ? `${formatIdeName$1(ideKey)} (detected)` : formatIdeName$1(ideKey)
 			};
 		});
 		const selected = await je({
@@ -1220,136 +2145,22 @@ const idesScanCommand = defineCommand({
 });
 
 //#endregion
-//#region src/commands/ides/index.ts
-const idesCommand = defineCommand({
-	meta: {
-		name: "ides",
-		description: "Manage IDE platform detection and configuration"
-	},
-	subCommands: {
-		configure: idesConfigureCommand,
-		list: idesListCommand,
-		scan: idesScanCommand
-	}
-});
-
-//#endregion
-//#region src/utils/first-run-preferences.ts
-var import_dist = require_dist();
-/**
-* Format an IDE platform key into a display name.
-* Duplicated here to avoid circular dependency with ides/utils.
-*/
-function formatIdeName$1(ideKey) {
-	return {
-		vscode: "VS Code",
-		jetbrains: "JetBrains",
-		cursor: "Cursor",
-		windsurf: "Windsurf",
-		antigravity: "Antigravity",
-		zed: "Zed"
-	}[ideKey] ?? ideKey;
-}
-/**
-* Shows the first-run preferences prompt if .baton/preferences.yaml doesn't exist.
-*
-* Asks the user whether to use global config or customize AI tools and IDEs
-* for this project, then writes the preferences file.
-*
-* @param projectRoot - Absolute path to the project root
-* @param nonInteractive - If true, writes useGlobal: true silently
-* @returns true if preferences were written, false if already existed
-*/
-async function promptFirstRunPreferences(projectRoot, nonInteractive) {
-	if (await readProjectPreferences(projectRoot)) return false;
-	if (nonInteractive) {
-		await writeProjectPreferences(projectRoot, {
-			version: "1.0",
-			ai: {
-				useGlobal: true,
-				tools: []
-			},
-			ide: {
-				useGlobal: true,
-				platforms: []
-			}
-		});
-		return true;
-	}
-	const aiMode = await Je({
-		message: "How do you want to configure AI tools for this project?",
-		options: [{
-			value: "global",
-			label: "Use global config",
-			hint: "recommended"
-		}, {
-			value: "customize",
-			label: "Customize for this project"
-		}]
-	});
-	if (Ct(aiMode)) return false;
-	let aiUseGlobal = true;
-	let aiTools = [];
-	if (aiMode === "customize") {
-		const globalTools = await getGlobalAiTools();
-		const allAdapters = getAllAIToolAdapters();
-		const selected = await je({
-			message: "Select AI tools for this project:",
-			options: allAdapters.map((adapter) => ({
-				value: adapter.key,
-				label: globalTools.includes(adapter.key) ? `${adapter.name} (in global config)` : adapter.name
-			})),
-			initialValues: globalTools
-		});
-		if (Ct(selected)) return false;
-		aiUseGlobal = false;
-		aiTools = selected;
-	}
-	const ideMode = await Je({
-		message: "How do you want to configure IDE platforms for this project?",
-		options: [{
-			value: "global",
-			label: "Use global config",
-			hint: "recommended"
-		}, {
-			value: "customize",
-			label: "Customize for this project"
-		}]
-	});
-	if (Ct(ideMode)) return false;
-	let ideUseGlobal = true;
-	let idePlatforms = [];
-	if (ideMode === "customize") {
-		const globalPlatforms = await getGlobalIdePlatforms();
-		const allIdeKeys = getRegisteredIdePlatforms();
-		const selected = await je({
-			message: "Select IDE platforms for this project:",
-			options: allIdeKeys.map((ideKey) => ({
-				value: ideKey,
-				label: globalPlatforms.includes(ideKey) ? `${formatIdeName$1(ideKey)} (in global config)` : formatIdeName$1(ideKey)
-			})),
-			initialValues: globalPlatforms
-		});
-		if (Ct(selected)) return false;
-		ideUseGlobal = false;
-		idePlatforms = selected;
+//#region src/commands/ides/index.ts
+const idesCommand = defineCommand({
+	meta: {
+		name: "ides",
+		description: "Manage IDE platform detection and configuration"
+	},
+	subCommands: {
+		configure: idesConfigureCommand,
+		list: idesListCommand,
+		scan: idesScanCommand
 	}
-	await writeProjectPreferences(projectRoot, {
-		version: "1.0",
-		ai: {
-			useGlobal: aiUseGlobal,
-			tools: aiTools
-		},
-		ide: {
-			useGlobal: ideUseGlobal,
-			platforms: idePlatforms
-		}
-	});
-	return true;
-}
+});
 
 //#endregion
 //#region src/utils/profile-selection.ts
+var import_dist = require_dist();
 /**
 * Discovers and prompts user to select a profile from a source.
 * Used by `baton init --profile` and `baton manage` (add profile).
@@ -1643,11 +2454,11 @@ const initCommand = defineCommand({
 		await promptFirstRunPreferences(cwd, !isInteractive);
 		if (profileSources.length > 0) {
 			const shouldSync = isInteractive ? await Re({
-				message: "Sync profiles now?",
+				message: "Fetch profiles and sync now?",
 				initialValue: true
 			}) : true;
 			if (!Ct(shouldSync) && shouldSync) await runBatonSync(cwd);
-			else R.info("Run 'baton sync' later to apply your profiles.");
+			else R.info("Run 'baton sync' later to fetch and apply your profiles.");
 		}
 		Le("Baton initialized successfully!");
 	}
@@ -2232,9 +3043,121 @@ const profileCommand = defineCommand({
 		description: "Manage profiles (create, list, remove)"
 	},
 	subCommands: {
-		create: () => import("./create-DEZA3dPb.mjs").then((m) => m.createCommand),
-		list: () => import("./list-BT2zFAVc.mjs").then((m) => m.profileListCommand),
-		remove: () => import("./remove-BBFBYUPy.mjs").then((m) => m.profileRemoveCommand)
+		create: () => import("./create-Y2IeW_fK.mjs").then((m) => m.createCommand),
+		list: () => import("./list-D3woEF2B.mjs").then((m) => m.profileListCommand),
+		remove: () => import("./remove-CsxkkNiu.mjs").then((m) => m.profileRemoveCommand)
+	}
+});
+
+//#endregion
+//#region src/commands/self-update.ts
+const __dirname$2 = dirname(fileURLToPath(import.meta.url));
+async function readCurrentVersion() {
+	try {
+		const pkg = JSON.parse(await readFile(join(__dirname$2, "../package.json"), "utf-8"));
+		return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}
+const selfUpdateCommand = defineCommand({
+	meta: {
+		name: "self-update",
+		description: "Update Baton to the latest stable version"
+	},
+	args: {
+		changelog: {
+			type: "boolean",
+			description: "Show release notes for the new version",
+			default: false
+		},
+		"dry-run": {
+			type: "boolean",
+			description: "Check for updates without performing the update",
+			default: false
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Skip confirmation prompt",
+			default: false
+		}
+	},
+	async run({ args }) {
+		We("baton self-update");
+		const currentVersion = await readCurrentVersion();
+		const s = bt();
+		s.start("Checking for updates...");
+		let latestVersion;
+		try {
+			latestVersion = (await checkLatestVersion()).version;
+		} catch (error) {
+			s.stop("Failed to check for updates");
+			R.error(error instanceof Error ? error.message : "Unknown error occurred");
+			Le("Update check failed.");
+			process.exit(1);
+		}
+		s.stop("Version check complete");
+		const { updateAvailable } = isUpdateAvailable(currentVersion, latestVersion);
+		if (!updateAvailable) {
+			R.success(`Already up to date (v${currentVersion}).`);
+			Le("No update needed.");
+			return;
+		}
+		const installMethod = await detectInstallMethod();
+		const displayCommand = formatInstallCommand(installMethod);
+		R.info([
+			`Current version: v${currentVersion}`,
+			`Latest version:  v${latestVersion}`,
+			installMethod.type !== "unknown" ? `Install method:  ${installMethod.type}` : ""
+		].filter(Boolean).join("\n"));
+		if (installMethod.type === "unknown") {
+			R.warn("Could not detect installation method.");
+			R.message([
+				"Please update manually using one of:",
+				"  npm update -g @baton-dx/cli",
+				"  pnpm update -g @baton-dx/cli",
+				"  bun update -g @baton-dx/cli",
+				"  brew upgrade baton-dx"
+			].join("\n"));
+			Le("Manual update required.");
+			return;
+		}
+		if (args["dry-run"]) {
+			R.info(`Would run: ${displayCommand}`);
+			Le("Dry run complete.");
+			return;
+		}
+		if (args.changelog) {
+			const changelogUrl = `https://github.com/baton-dx/baton/releases/tag/v${latestVersion}`;
+			R.info(`Release notes: ${changelogUrl}`);
+		}
+		if (!args.yes) {
+			const confirmed = await Re({ message: `Update to v${latestVersion}?` });
+			if (Ct(confirmed) || !confirmed) {
+				Le("Update cancelled.");
+				return;
+			}
+		}
+		const updateSpinner = bt();
+		updateSpinner.start(`Running: ${displayCommand}`);
+		try {
+			await new Promise((resolve, reject) => {
+				execFile(installMethod.bin, installMethod.args, (error) => {
+					if (error) reject(error);
+					else resolve();
+				});
+			});
+			updateSpinner.stop(`Successfully updated to v${latestVersion}`);
+			Le("Update complete!");
+		} catch (error) {
+			updateSpinner.stop("Update failed");
+			const message = error instanceof Error ? error.message : "Unknown error";
+			R.error(`Failed to run: ${displayCommand}`);
+			R.error(message);
+			Le("Update failed. Please try updating manually.");
+			process.exit(1);
+		}
 	}
 });
 
@@ -2654,122 +3577,10 @@ const sourceCommand = defineCommand({
 
 //#endregion
 //#region src/commands/sync.ts
-const validCategories = [
-	"ai",
-	"files",
-	"ide"
-];
-/** Get or initialize placed files for a profile, avoiding unsafe `as` casts on Map.get(). */
-function getOrCreatePlacedFiles(map, profileName) {
-	let files = map.get(profileName);
-	if (!files) {
-		files = {};
-		map.set(profileName, files);
-	}
-	return files;
-}
-/**
-* Recursively copy all files from sourceDir to targetDir.
-* Returns the number of files written (skips identical content).
-*/
-async function copyDirectoryRecursive(sourceDir, targetDir) {
-	await mkdir(targetDir, { recursive: true });
-	const entries = await readdir(sourceDir, { withFileTypes: true });
-	let placed = 0;
-	for (const entry of entries) {
-		const sourcePath = resolve(sourceDir, entry.name);
-		const targetPath = resolve(targetDir, entry.name);
-		if (entry.isDirectory()) placed += await copyDirectoryRecursive(sourcePath, targetPath);
-		else {
-			const content = await readFile(sourcePath, "utf-8");
-			if (await readFile(targetPath, "utf-8").catch(() => void 0) !== content) {
-				await writeFile(targetPath, content, "utf-8");
-				placed++;
-			}
-		}
-	}
-	return placed;
-}
-/**
-* Handle .gitignore update based on the project manifest's gitignore setting.
-*
-* When gitignore is enabled (default): writes comprehensive patterns for ALL
-* known AI tools and IDE platforms to ensure stable, dev-independent content.
-* When disabled: removes any existing managed section.
-* Always ensures .baton/ is gitignored regardless of setting.
-*/
-async function handleGitignoreUpdate(params) {
-	const { projectManifest, fileMap, projectRoot, spinner } = params;
-	const gitignoreEnabled = projectManifest.gitignore !== false;
-	await ensureBatonDirGitignored(projectRoot);
-	if (gitignoreEnabled) {
-		spinner.start("Updating .gitignore...");
-		const updated = await updateGitignore(projectRoot, collectComprehensivePatterns({ fileTargets: [...fileMap.values()].map((f) => f.target) }));
-		spinner.stop(updated ? "Updated .gitignore with managed patterns" : ".gitignore already up to date");
-	} else {
-		spinner.start("Checking .gitignore...");
-		const removed = await removeGitignoreManagedSection(projectRoot);
-		spinner.stop(removed ? "Removed managed section from .gitignore" : ".gitignore unchanged");
-	}
-}
-/**
-* Generate and write the baton.lock lockfile from placed files and profile metadata.
-*/
-async function writeLockData(params) {
-	const { allProfiles, sourceShas, placedFiles, projectRoot, spinner } = params;
-	spinner.start("Updating lockfile...");
-	const lockPackages = {};
-	for (const profile of allProfiles) lockPackages[profile.name] = {
-		source: profile.source,
-		resolved: profile.source,
-		version: profile.manifest.version,
-		sha: sourceShas.get(profile.source) || "unknown",
-		files: placedFiles.get(profile.name) || {}
-	};
-	await writeLock(generateLock(lockPackages), resolve(projectRoot, "baton.lock"));
-	spinner.stop("Lockfile updated");
-}
-/**
-* Detect and remove files that were in the previous lockfile but are no longer
-* part of the current sync. Cleans up empty parent directories.
-*/
-async function cleanupOrphanedFiles(params) {
-	const { previousPaths, placedFiles, projectRoot, dryRun, autoYes, spinner } = params;
-	if (previousPaths.size === 0) return;
-	const currentPaths = /* @__PURE__ */ new Set();
-	for (const files of placedFiles.values()) for (const filePath of Object.keys(files)) currentPaths.add(filePath);
-	const orphanedPaths = [...previousPaths].filter((prev) => !currentPaths.has(prev));
-	if (orphanedPaths.length === 0) return;
-	if (dryRun) {
-		R.warn(`Would remove ${orphanedPaths.length} orphaned file(s):`);
-		for (const orphanedPath of orphanedPaths) R.info(`  Removed: ${orphanedPath}`);
-		return;
-	}
-	R.warn(`Found ${orphanedPaths.length} orphaned file(s) to remove:`);
-	for (const orphanedPath of orphanedPaths) R.info(`  Removed: ${orphanedPath}`);
-	let shouldRemove = autoYes;
-	if (!autoYes) {
-		const confirmed = await Re({
-			message: `Remove ${orphanedPaths.length} orphaned file(s)?`,
-			initialValue: true
-		});
-		if (Ct(confirmed)) {
-			R.info("Skipped orphan removal.");
-			shouldRemove = false;
-		} else shouldRemove = confirmed;
-	}
-	if (!shouldRemove) {
-		R.info("Orphan removal skipped.");
-		return;
-	}
-	spinner.start("Removing orphaned files...");
-	const removedCount = await removePlacedFiles(orphanedPaths, projectRoot);
-	spinner.stop(`Removed ${removedCount} orphaned file(s)`);
-}
 const syncCommand = defineCommand({
 	meta: {
 		name: "sync",
-		description: "Sync all profiles, skills, agents, and rules to installed AI tools"
+		description: "Fetch latest versions, sync all configurations, and update lockfile"
 	},
 	args: {
 		"dry-run": {
@@ -2792,11 +3603,6 @@ const syncCommand = defineCommand({
 			alias: "v",
 			description: "Show detailed output for each placed file",
 			default: false
-		},
-		fresh: {
-			type: "boolean",
-			description: "Force an immediate source refresh (ignore cache TTL)",
-			default: false
 		}
 	},
 	async run({ args }) {
@@ -2804,7 +3610,6 @@ const syncCommand = defineCommand({
 		const categoryArg = args.category;
 		const autoYes = args.yes;
 		const verbose = args.verbose;
-		const fresh = args.fresh;
 		let category;
 		if (categoryArg) {
 			if (!validCategories.includes(categoryArg)) {
@@ -2833,11 +3638,6 @@ const syncCommand = defineCommand({
 				process.exit(1);
 			}
 			await promptFirstRunPreferences(projectRoot, !!args.yes);
-			let cacheTtlHours = 24;
-			try {
-				cacheTtlHours = (await loadGlobalConfig()).sync?.cacheTtlHours ?? 24;
-			} catch {}
-			const maxCacheAgeMs = fresh ? 0 : cacheTtlHours * 60 * 60 * 1e3;
 			const previousPaths = /* @__PURE__ */ new Set();
 			try {
 				const previousLock = await readLock(resolve(projectRoot, "baton.lock"));
@@ -2866,12 +3666,19 @@ const syncCommand = defineCommand({
 				} else {
 					const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
 					if (!url) throw new Error(`Invalid source: ${profileSource.source}`);
+					let resolvedRef;
+					try {
+						resolvedRef = await resolveVersion(url, "latest");
+						if (verbose) R.info(`Resolved latest: ${profileSource.source} → ${resolvedRef.slice(0, 12)}`);
+					} catch {
+						resolvedRef = profileSource.version || "HEAD";
+						if (verbose) R.warn(`Could not resolve latest for ${url}, using ${resolvedRef}`);
+					}
 					const cloned = await cloneGitSource({
 						url,
-						ref: profileSource.version,
+						ref: resolvedRef,
 						subpath: "subpath" in parsed ? parsed.subpath : void 0,
-						useCache: true,
-						maxCacheAgeMs
+						useCache: false
 					});
 					manifestPath = resolve(cloned.localPath, "baton.profile.yaml");
 					sourceShas.set(profileSource.source, cloned.sha);
@@ -3086,10 +3893,9 @@ const syncCommand = defineCommand({
 				} else if (parsed.provider === "github" || parsed.provider === "gitlab" || parsed.provider === "git") {
 					const cloned = await cloneGitSource({
 						url: parsed.provider === "git" ? parsed.url : parsed.url,
-						ref: profileSource.version,
+						ref: sourceShas.get(profileSource.source) || profileSource.version,
 						subpath: "subpath" in parsed ? parsed.subpath : void 0,
-						useCache: true,
-						maxCacheAgeMs
+						useCache: true
 					});
 					for (const prof of allProfiles) if (prof.source === profileSource.source) profileLocalPaths.set(prof.name, cloned.localPath);
 				}
@@ -3443,167 +4249,37 @@ const syncCommand = defineCommand({
 const updateCommand = defineCommand({
 	meta: {
 		name: "update",
-		description: "Check for and apply updates to installed profiles and packages"
+		description: "(deprecated) Use 'baton sync' instead"
 	},
 	args: {
 		"dry-run": {
 			type: "boolean",
-			description: "Show available updates without applying them",
+			description: "Show what would be done without writing files",
 			default: false
 		},
+		category: {
+			type: "string",
+			description: "Sync only a specific category: ai, files, or ide",
+			required: false
+		},
 		yes: {
 			type: "boolean",
-			description: "Apply all updates without confirmation prompts",
+			description: "Run non-interactively (no prompts)",
+			default: false
+		},
+		verbose: {
+			type: "boolean",
+			alias: "v",
+			description: "Show detailed output for each placed file",
 			default: false
 		}
 	},
-	async run({ args }) {
-		const dryRun = args["dry-run"];
-		const autoConfirm = args.yes;
-		We("Baton Update");
-		const cwd = process.cwd();
-		const manifestPath = resolve(cwd, "baton.yaml");
-		const lockfilePath = resolve(cwd, "baton.lock");
-		const spinner = bt();
-		spinner.start("Loading project configuration");
-		let manifest;
-		try {
-			manifest = await loadProjectManifest(manifestPath);
-		} catch (error) {
-			spinner.stop("Failed to load baton.yaml");
-			Ne(error instanceof Error ? error.message : "Could not load project manifest");
-			process.exit(1);
-		}
-		let lockfile = null;
-		try {
-			lockfile = await loadLockfile(lockfilePath);
-			spinner.stop("Configuration loaded");
-		} catch {
-			spinner.stop("Configuration loaded (no lockfile found)");
-			Ve("No lockfile found. Run 'baton sync' first to create one.");
-		}
-		spinner.start("Checking for updates");
-		const updateCandidates = [];
-		for (const profile of manifest.profiles || []) try {
-			const parsed = parseSource(profile.source);
-			if (parsed.provider === "local" || parsed.provider === "file") continue;
-			const packageName = getPackageName(parsed);
-			const currentVersion = lockfile?.packages[packageName]?.version || profile.version || "HEAD";
-			const latestVersion = await getLatestVersion(parsed);
-			if (currentVersion !== latestVersion) {
-				const changes = await getChangeSummary(parsed, currentVersion, latestVersion);
-				updateCandidates.push({
-					name: packageName,
-					source: profile.source,
-					currentVersion,
-					latestVersion,
-					changes
-				});
-			}
-		} catch (error) {
-			if (error instanceof SourceParseError) R.warn(`Skipping invalid source: ${profile.source}`);
-		}
-		spinner.stop("Update check complete");
-		if (updateCandidates.length === 0) {
-			Le("All packages are up to date!");
-			process.exit(0);
-		}
-		Ve(`Found ${updateCandidates.length} update${updateCandidates.length > 1 ? "s" : ""}`);
-		for (const candidate of updateCandidates) {
-			console.log(`\n📦 ${candidate.name}: ${candidate.currentVersion} → ${candidate.latestVersion}`);
-			if (candidate.changes.length > 0) {
-				console.log("   Changes:");
-				for (const change of candidate.changes) console.log(`   - ${change}`);
-			}
-		}
-		if (dryRun) {
-			Le("Dry-run mode enabled. No changes were made.\nRun 'baton update' without --dry-run to apply updates.");
-			process.exit(0);
-		}
-		if (!autoConfirm) {
-			const confirmed = await Re({
-				message: `Apply ${updateCandidates.length} update${updateCandidates.length > 1 ? "s" : ""}?`,
-				initialValue: true
-			});
-			if (Ct(confirmed) || !confirmed) {
-				Ne("Update cancelled");
-				process.exit(0);
-			}
-		}
-		spinner.start("Applying updates");
-		const updatedPackages = {};
-		for (const candidate of updateCandidates) try {
-			const parsed = parseSource(candidate.source);
-			const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
-			if (!url) {
-				spinner.stop("Update failed");
-				Ne(`Cannot update local source: ${candidate.name}`);
-				process.exit(1);
-			}
-			const clonedSource = await cloneGitSource({
-				url,
-				ref: candidate.latestVersion,
-				subpath: parsed.provider !== "local" && "subpath" in parsed ? parsed.subpath : void 0
-			});
-			const files = {};
-			updatedPackages[candidate.name] = {
-				source: candidate.source,
-				resolved: url,
-				version: candidate.latestVersion,
-				sha: clonedSource.sha,
-				files
-			};
-		} catch (error) {
-			spinner.stop("Update failed");
-			Ne(`Failed to update ${candidate.name}: ${error instanceof Error ? error.message : "Unknown error"}`);
-			process.exit(1);
-		}
-		const newLock = generateLock(updatedPackages);
-		if (lockfile) {
-			lockfile.packages = {
-				...lockfile.packages,
-				...newLock.packages
-			};
-			lockfile.locked_at = (/* @__PURE__ */ new Date()).toISOString();
-			await writeLock(lockfile, lockfilePath);
-		} else await writeLock(newLock, lockfilePath);
-		spinner.stop("Updates applied successfully");
-		Le(`✅ Updated ${updateCandidates.length} package${updateCandidates.length > 1 ? "s" : ""}!\n\nRun 'baton sync' to apply the updated configurations.`);
-		process.exit(0);
+	async run(context) {
+		R.warn("`baton update` is deprecated. Use `baton sync` instead.");
+		R.info("");
+		if (syncCommand.run) await syncCommand.run(context);
 	}
 });
-function getPackageName(parsed) {
-	if (parsed.provider === "local" || parsed.provider === "file") return parsed.path;
-	if (parsed.provider === "github" || parsed.provider === "gitlab") return `${parsed.org}/${parsed.repo}`;
-	if (parsed.provider === "npm") return parsed.scope ? `${parsed.scope}/${parsed.package}` : parsed.package;
-	if (parsed.provider === "git") return parsed.url;
-	return "unknown";
-}
-async function getLatestVersion(parsed) {
-	if (parsed.provider === "local") return "local";
-	const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
-	if (!url) return "HEAD";
-	return await resolveVersion(url, "latest");
-}
-async function getChangeSummary(parsed, fromVersion, toVersion) {
-	try {
-		const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
-		if (!url) return [`Updated from ${fromVersion} to ${toVersion}`];
-		const clonedSource = await cloneGitSource({
-			url,
-			ref: toVersion,
-			subpath: parsed.provider !== "local" && "subpath" in parsed ? parsed.subpath : void 0
-		});
-		const simpleGit = (await import("./esm-CuRZ1S4C.mjs")).default;
-		return (await simpleGit(clonedSource.localPath).log({
-			from: fromVersion,
-			to: toVersion,
-			maxCount: 5
-		})).all.map((commit) => commit.message.split("\n")[0]);
-	} catch {
-		return [`Updated from ${fromVersion} to ${toVersion}`];
-	}
-}
 
 //#endregion
 //#region src/index.ts
@@ -3640,6 +4316,7 @@ runMain(defineCommand({
 	},
 	subCommands: {
 		init: initCommand,
+		apply: applyCommand,
 		sync: syncCommand,
 		update: updateCommand,
 		diff: diffCommand,
@@ -3648,7 +4325,8 @@ runMain(defineCommand({
 		source: sourceCommand,
 		profile: profileCommand,
 		"ai-tools": aiToolsCommand,
-		ides: idesCommand
+		ides: idesCommand,
+		"self-update": selfUpdateCommand
 	},
 	run({ args }) {
 		if (Object.keys(args).length === 0) {
@@ -3661,8 +4339,9 @@ runMain(defineCommand({
 			console.log("");
 			console.log("Available commands:");
 			console.log("  init       Initialize Baton in your project");
-			console.log("  sync       Sync all configurations to installed AI tools");
-			console.log("  update     Check for and apply updates to installed packages");
+			console.log("  apply      Apply locked configurations (deterministic, reproducible)");
+			console.log("  sync       Fetch latest versions, sync, and update lockfile");
+			console.log("  update     (deprecated) Use 'baton sync' instead");
 			console.log("  diff       Compare local files with remote source versions");
 			console.log("  manage     Interactive project management wizard");
 			console.log("  config     Show dashboard overview or configure settings");
@@ -3673,6 +4352,9 @@ runMain(defineCommand({
 			console.log("  ai-tools   Manage AI tool detection and configuration");
 			console.log("  ides       Manage IDE platform detection and configuration");
 			console.log("");
+			console.log("Maintenance:");
+			console.log("  self-update  Update Baton to the latest stable version");
+			console.log("");
 			console.log("Global Options:");
 			console.log("  --help, -h         Show this help message");
 			console.log("  --version, -v      Show version number");