skilld 1.7.3 → 2.0.0

package/dist/_chunks/sync.mjs

@@ -1,266 +1,519 @@
-import { a as getModelLabel, i as getAvailableModels, s as optimizeDocs, t as detectImportedPackages } from "./agent.mjs";
-import { i as CACHE_DIR, r as getVersionKey, t as getCacheDir } from "./version.mjs";
-import { r as resolvePkgDir } from "./prepare.mjs";
-import { n as sanitizeMarkdown } from "./sanitize.mjs";
-import { a as hasShippedDocs, d as linkPkgNamed, g as readCachedSection, i as getPkgKeyFiles, m as listReferenceFiles, r as ensureCacheDir, s as isCached } from "./cache.mjs";
+import { i as getModelLabel, n as detectImportedPackages } from "./agent.mjs";
+import { a as sanitizeName, c as formatDuration, g as todayIsoDate, h as timedSpinner, i as linkSkillToAgents, r as computeSkillDirName, t as writeGeneratedSkillMd } from "./prompts.mjs";
+import { _ as skillRefsSection, f as getSharedSkillsDir } from "./paths.mjs";
+import { c as getVersionKey } from "./prepare.mjs";
+import { d as readConfig, r as ensureCacheDir, s as getActiveFeatures, t as createReferenceCache } from "./cache.mjs";
+import { r as suggestPrepareHook } from "./prepare-hook2.mjs";
+import { E as resolveGitHubRepo, L as parseGitHubRepoSlug, U as isPrerelease, i as resolvePackageOrCrate, l as toStoragePackageName, m as searchNpmPackages, o as isCrateSpec, p as fetchPkgDist, t as semverDiff, z as parsePackageSpec } from "./semver.mjs";
 import { i as parseFrontmatter } from "./markdown.mjs";
-import { a as semverDiff, n as getSharedSkillsDir, t as SHARED_SKILLS_DIR } from "./shared.mjs";
-import { J as isPrerelease, M as resolveGitHubRepo, f as resolvePackageDocsWithAttempts, i as fetchPkgDist, it as parsePackageSpec, m as fetchGitSkills, nt as parseGitHubRepoSlug, p as searchNpmPackages, s as readLocalDependencies, w as resolveCrateDocsWithAttempts } from "./sources.mjs";
-import { a as targets } from "./detect.mjs";
-import { c as wrapSection, n as SECTION_OUTPUT_FILES, r as buildAllSectionPrompts, s as portabilizePrompt, t as SECTION_MERGE_ORDER } from "./prompts.mjs";
-import { _ as timedSpinner, i as computeSkillDirName, n as writeGeneratedSkillMd, o as linkSkillToAgents, r as writeSkillMd, s as sanitizeName, u as formatDuration, v as todayIsoDate } from "./skill.mjs";
-import { a as readConfig, o as registerProject, r as hasCompletedWizard, t as defaultFeatures } from "./config.mjs";
-import { S as suggestPrepareHook, _ as promptForAgent, b as resolveAgent, f as introLine, o as getInstalledGenerators, p as isInteractive, x as sharedArgs } from "./cli-helpers.mjs";
-import { a as readLock, c as writeLock, n as parsePackageNames, o as removeLockEntry, r as parsePackages } from "./lockfile.mjs";
-import { t as getProjectState } from "./skills.mjs";
-import { n as resolveSkillName, r as toStoragePackageName, t as parseSkillInput } from "./prefix.mjs";
-import { t as runWizard } from "./wizard.mjs";
-import { S as writePromptFiles, _ as linkAllReferences, b as selectLlmConfig, c as ejectReferences, d as ensureGitignore, f as fetchAndCacheResources, g as indexResources, h as handleShippedSkills, l as enhanceSkillWithLLM, m as forceClearCache, n as RESOLVE_STEP_LABELS, o as detectChangelog, p as findRelatedSkills, t as DEFAULT_SECTIONS, u as ensureAgentInstructions, v as resolveBaseDir, y as resolveLocalDep } from "./sync-shared2.mjs";
+import { a as parsePackageNames, c as readLock, n as findSkillDirByPackage } from "./lockfile.mjs";
+import { a as ensureProjectFiles, c as linkShippedToAgents, l as resolveBaseDir, o as handleShippedSkills, s as installSkill } from "./skill-installer2.mjs";
+import { a as prepareSkillReferences, c as selectLlmConfig, d as runSkillEnhancement, f as writeBaseSkill, i as findRelatedSkills, l as applyCachedSections, o as DEFAULT_SECTIONS, p as writePromptFiles, r as fetchAndCacheResources, s as resolveAutoModel, t as buildSkillContext } from "./pipeline.mjs";
 import { n as shutdownWorker } from "./pool2.mjs";
-import { dirname, join, relative, resolve } from "pathe";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import pLimit from "p-limit";
-import { isCI } from "std-env";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { styleText } from "node:util";
 import * as p from "@clack/prompts";
-import { defineCommand } from "citty";
+import pLimit from "p-limit";
+import { join, relative, resolve } from "pathe";
 import logUpdate from "log-update";
-const TELEMETRY_URL = "https://add-skill.vercel.sh/t";
-const SKILLS_VERSION = "1.3.9";
-function isEnabled() {
-	return !process.env.DISABLE_TELEMETRY && !process.env.DO_NOT_TRACK;
-}
-function track(data) {
-	if (!isEnabled()) return;
-	try {
-		const params = new URLSearchParams();
-		params.set("v", SKILLS_VERSION);
-		if (isCI) params.set("ci", "1");
-		for (const [key, value] of Object.entries(data)) if (value !== void 0 && value !== null) params.set(key, String(value));
-		fetch(`${TELEMETRY_URL}?${params.toString()}`).catch(() => {});
-	} catch {}
-}
-async function syncGitSkills(opts) {
-	const { source, agent, global: isGlobal, yes } = opts;
-	const cwd = process.cwd();
-	const agentConfig = targets[agent];
-	const baseDir = isGlobal ? join(CACHE_DIR, "skills") : join(cwd, agentConfig.skillsDir);
-	const label = source.type === "local" ? source.localPath : `${source.owner}/${source.repo}`;
-	const spin = timedSpinner();
-	spin.start(`Fetching skills from ${label}`);
-	const { skills } = await fetchGitSkills(source, (msg) => spin.message(msg));
-	if (skills.length === 0) {
-		if (source.type === "github" && source.owner && source.repo) {
-			spin.stop(`No pre-authored skills in ${label}, generating from repo docs...`);
-			return syncGitHubRepo(opts);
+import { createHooks } from "hookable";
+const npmResolver = async (spec, opts) => {
+	const resolution = await resolvePackageOrCrate(spec, {
+		cwd: opts.cwd,
+		onProgress: (msg) => opts.onProgress(`${spec}: ${msg}`)
+	});
+	const { isCrate, packageName, identityPackageName, storagePackageName, requestedTag, localVersion, attempts, registryVersion } = resolution;
+	if (!resolution.resolved) {
+		const result = {
+			identityName: identityPackageName,
+			attempts,
+			registryVersion
+		};
+		if (!isCrate) {
+			const shipped = handleShippedSkills(packageName, localVersion || registryVersion || "latest", opts.cwd, opts.agent, opts.global);
+			if (shipped) result.shipped = shipped.shipped;
 		}
-		spin.stop(`No skills found in ${label}`);
-		return;
+		return result;
 	}
-	spin.stop(`Found ${skills.length} skill(s) in ${label}`);
-	let selected = skills;
-	if (opts.skillFilter?.length) {
-		const filterSet = new Set(opts.skillFilter.map((s) => s.toLowerCase().replace(/-skilld$/, "")));
-		selected = skills.filter((s) => filterSet.has(s.name.toLowerCase().replace(/-skilld$/, "")));
-		if (selected.length === 0) {
-			p.log.warn(`No skills matched: ${opts.skillFilter.join(", ")}`);
-			p.log.message(`Available: ${skills.map((s) => s.name).join(", ")}`);
-			return;
+	const resolved = resolution.resolved;
+	return {
+		identityName: identityPackageName,
+		storageName: storagePackageName,
+		version: isCrate ? resolved.version || requestedTag || "latest" : localVersion || resolved.version || "latest",
+		resolved,
+		kind: isCrate ? "crate" : "npm",
+		requestedTag,
+		localVersion
+	};
+};
+function createGithubResolver(owner, repo) {
+	return async (_spec, opts) => {
+		const resolved = await resolveGitHubRepo(owner, repo, (msg) => opts.onProgress(msg));
+		if (!resolved) return {
+			identityName: `${owner}-${repo}`,
+			attempts: [{
+				source: "github-meta",
+				status: "not-found",
+				message: `Could not find docs for ${owner}/${repo}`
+			}]
+		};
+		const repoUrl = `https://github.com/${owner}/${repo}`;
+		const name = `${owner}-${repo}`;
+		return {
+			identityName: name,
+			storageName: name,
+			version: resolved.version || "main",
+			resolved: {
+				...resolved,
+				repoUrl
+			},
+			kind: "github"
+		};
+	};
+}
+const RATE_LIMIT_RE = /\b429\b|rate.?limit|exhausted.*capacity|quota.*reset/i;
+async function runBaseSync(spec, config, hooks, resolver, cwd, defaultSections) {
+	await hooks.callHook("resolve:start", { spec });
+	const resolverResult = await resolver(spec, {
+		cwd,
+		agent: config.agent,
+		global: config.global,
+		onProgress: (msg) => hooks.callHook("resolve:progress", {
+			spec,
+			message: msg
+		})
+	});
+	if (!("resolved" in resolverResult)) {
+		if (resolverResult.shipped && resolverResult.shipped.length > 0) {
+			for (const s of resolverResult.shipped) await hooks.callHook("shipped:installed", {
+				spec,
+				skillName: s.skillName,
+				skillDir: s.skillDir
+			});
+			return { kind: "shipped" };
 		}
-	} else if (source.skillPath) selected = skills;
-	else if (skills.length > 1 && !yes) {
-		const choices = await p.autocompleteMultiselect({
-			message: `Select skills to install from ${label}`,
-			options: skills.map((s) => ({
-				label: s.name.replace(/-skilld$/, ""),
-				value: s.name,
-				hint: s.description || s.path
-			})),
-			initialValues: []
+		await hooks.callHook("resolve:failed", {
+			spec,
+			identityName: resolverResult.identityName,
+			attempts: resolverResult.attempts
 		});
-		if (p.isCancel(choices)) return;
-		const selectedNames = new Set(choices);
-		selected = skills.filter((s) => selectedNames.has(s.name));
-		if (selected.length === 0) return;
+		return {
+			kind: "unresolved",
+			unresolved: resolverResult
+		};
 	}
-	mkdirSync(baseDir, { recursive: true });
-	for (const skill of selected) {
-		const skillDir = join(baseDir, skill.name);
-		mkdirSync(skillDir, { recursive: true });
-		writeSkillMd(skillDir, sanitizeMarkdown(skill.content));
-		if (skill.files.length > 0) for (const f of skill.files) {
-			const filePath = join(skillDir, f.path);
-			mkdirSync(dirname(filePath), { recursive: true });
-			writeFileSync(filePath, f.content);
+	const { identityName, storageName, version, resolved, kind, requestedTag, localVersion } = resolverResult;
+	const cache = createReferenceCache(storageName, version);
+	if (config.force) cache.clearForce();
+	const useCache = cache.has();
+	if (kind !== "crate" && !existsSync(join(cwd, "node_modules", identityName))) {
+		await hooks.callHook("dist:downloading", { spec });
+		await fetchPkgDist(identityName, version);
+	}
+	if (kind !== "crate") {
+		const shipped = handleShippedSkills(identityName, version, cwd, config.agent, config.global);
+		if (shipped) {
+			linkShippedToAgents(shipped.shipped, cwd, config.agent, config.global);
+			for (const s of shipped.shipped) await hooks.callHook("shipped:installed", {
+				spec,
+				skillName: s.skillName,
+				skillDir: s.skillDir
+			});
+			return { kind: "shipped" };
 		}
-		const sourceType = source.type === "local" ? "local" : source.type;
-		writeLock(baseDir, skill.name, {
-			source: sourceType,
-			repo: source.type === "local" ? source.localPath : `${source.owner}/${source.repo}`,
-			path: skill.path || void 0,
-			ref: source.ref || "main",
-			syncedAt: todayIsoDate(),
-			generator: "external"
-		});
 	}
-	if (!isGlobal) registerProject(cwd);
-	if (source.type !== "local" && source.owner && source.repo) track({
-		event: "install",
-		source: `${source.owner}/${source.repo}`,
-		skills: selected.map((s) => s.name).join(","),
-		agents: agent,
-		...isGlobal && { global: "1" },
-		sourceType: source.type
+	await hooks.callHook("resolve:done", {
+		spec,
+		version,
+		cached: useCache,
+		force: config.force
 	});
-	const names = selected.map((s) => `\x1B[36m${s.name}\x1B[0m`).join(", ");
-	p.log.success(`Installed ${names}`);
-}
-async function syncGitHubRepo(opts) {
-	const { source, agent, global: isGlobal, yes } = opts;
-	const owner = source.owner;
-	const repo = source.repo;
-	const cwd = process.cwd();
-	const spin = timedSpinner();
-	spin.start(`Resolving ${owner}/${repo}`);
-	const resolved = await resolveGitHubRepo(owner, repo, (msg) => spin.message(msg));
-	if (!resolved) {
-		spin.stop(`Could not find docs for ${owner}/${repo}`);
-		return;
+	if (kind === "npm" && !localVersion && !requestedTag && !isPrerelease(version)) {
+		const nextTag = resolved.distTags?.next ?? resolved.distTags?.beta ?? resolved.distTags?.alpha;
+		if (nextTag && (!resolved.releasedAt || !nextTag.releasedAt || nextTag.releasedAt > resolved.releasedAt)) await hooks.callHook("warn", {
+			spec,
+			message: `No local dependency found — using latest stable (${version}). Prerelease ${nextTag.version} available: skilld add ${identityName}@beta`
+		});
 	}
-	const repoUrl = `https://github.com/${owner}/${repo}`;
-	const packageName = `${owner}-${repo}`;
-	const version = resolved.version || "main";
-	const versionKey = getVersionKey(version);
-	const useCache = isCached(packageName, version);
-	spin.stop(`Resolved ${owner}/${repo}@${useCache ? versionKey : version}${useCache ? " (cached)" : ""}`);
-	ensureCacheDir();
-	const baseDir = resolveBaseDir(cwd, agent, isGlobal);
-	const skillDirName = sanitizeName(`${owner}-${repo}`);
-	const skillDir = join(baseDir, skillDirName);
+	cache.ensure();
+	const isEject = !!config.eject;
+	const baseDir = resolveBaseDir(cwd, config.agent, config.global);
+	let skillDirName = config.name ? sanitizeName(config.name) : computeSkillDirName(storageName);
+	if (config.mode === "update" && !config.name && !isEject) {
+		const lock = readLock(baseDir);
+		const found = lock ? findSkillDirByPackage(lock, identityName) : null;
+		if (found) skillDirName = found;
+	}
+	const skillDir = isEject ? typeof config.eject === "string" ? join(resolve(cwd, config.eject), skillDirName) : join(cwd, "skills", skillDirName) : join(baseDir, skillDirName);
 	mkdirSync(skillDir, { recursive: true });
-	const features = readConfig().features ?? defaultFeatures;
-	const resSpin = timedSpinner();
-	resSpin.start("Finding resources");
+	const existingLock = isEject ? void 0 : readLock(baseDir)?.skills[skillDirName];
+	if (existingLock && existingLock.packageName && existingLock.packageName !== identityName) return {
+		kind: "merge-needed",
+		state: {
+			identityName,
+			storageName,
+			version,
+			resolved,
+			baseDir,
+			skillDir,
+			skillDirName,
+			existingLock
+		}
+	};
+	const updateCtx = config.mode === "update" && existingLock ? {
+		oldVersion: existingLock.version,
+		newVersion: version,
+		syncedAt: existingLock.syncedAt,
+		wasEnhanced: (() => {
+			const skillMdPath = join(skillDir, "SKILL.md");
+			if (!existsSync(skillMdPath)) return false;
+			return !!parseFrontmatter(readFileSync(skillMdPath, "utf-8")).generated_by;
+		})()
+	} : void 0;
+	const features = getActiveFeatures(config.noSearch ? { search: false } : void 0);
+	await hooks.callHook("fetch:start", { spec });
 	const resources = await fetchAndCacheResources({
-		packageName,
+		packageName: storageName,
 		resolved,
 		version,
 		useCache,
 		features,
-		from: opts.from,
-		onProgress: (msg) => resSpin.message(msg)
+		from: config.from,
+		onProgress: (msg) => hooks.callHook("fetch:progress", {
+			spec,
+			message: msg
+		})
 	});
-	const resParts = [];
+	const parts = [];
 	if (resources.docsToIndex.length > 0) {
 		const docCount = resources.docsToIndex.filter((d) => d.metadata?.type === "doc").length;
-		if (docCount > 0) resParts.push(`${docCount} docs`);
-	}
-	if (resources.hasIssues) resParts.push("issues");
-	if (resources.hasDiscussions) resParts.push("discussions");
-	if (resources.hasReleases) resParts.push("releases");
-	resSpin.stop(`Fetched ${resParts.length > 0 ? resParts.join(", ") : "resources"}`);
-	for (const w of resources.warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
-	linkAllReferences(skillDir, packageName, cwd, version, resources.docsType, void 0, features);
-	if (features.search) {
-		const idxSpin = timedSpinner();
-		idxSpin.start("Creating search index");
-		await indexResources({
-			packageName,
+		if (docCount > 0) parts.push(`${docCount} docs`);
+	}
+	if (resources.hasIssues) parts.push("issues");
+	if (resources.hasDiscussions) parts.push("discussions");
+	if (resources.hasReleases) parts.push("releases");
+	await hooks.callHook("fetch:done", {
+		spec,
+		parts,
+		cached: resources.usedCache
+	});
+	for (const w of resources.warnings) await hooks.callHook("warn", {
+		spec,
+		message: w
+	});
+	if (features.search) await hooks.callHook("index:start", { spec });
+	const prepared = await prepareSkillReferences({
+		packageName: storageName,
+		version,
+		cwd,
+		skillDir,
+		resources,
+		features,
+		baseDir,
+		onIndexProgress: (msg) => hooks.callHook("index:progress", {
+			spec,
+			message: msg
+		})
+	});
+	if (features.search) await hooks.callHook("index:done", { spec });
+	if (!isEject) {
+		const repoSlug = parseGitHubRepoSlug(resolved.repoUrl);
+		cache.linkPkgNamed(skillDir, cwd);
+		const lock = {
+			packageName: identityName,
 			version,
+			repo: repoSlug,
+			source: resources.docSource,
+			syncedAt: todayIsoDate(),
+			generator: "skilld"
+		};
+		installSkill({
 			cwd,
-			docsToIndex: resources.docsToIndex,
-			features,
-			onProgress: (msg) => idxSpin.message(msg)
+			agent: config.agent,
+			global: config.global,
+			baseDir,
+			skillDirName,
+			lock,
+			dedupePackageName: identityName,
+			skipLinkAgents: true
 		});
-		idxSpin.stop("Search index ready");
 	}
-	const hasChangelog = detectChangelog(resolvePkgDir(packageName, cwd, version), getCacheDir(packageName, version));
-	const shippedDocs = hasShippedDocs(packageName, cwd, version);
-	const pkgFiles = getPkgKeyFiles(packageName, cwd, version);
-	writeLock(baseDir, skillDirName, {
-		packageName,
+	const allPackages = parsePackageNames((isEject ? void 0 : readLock(baseDir)?.skills[skillDirName])?.packages);
+	const ctx = buildSkillContext({
+		packageName: identityName,
+		cachePackageName: storageName,
 		version,
-		repo: `${owner}/${repo}`,
-		source: resources.docSource,
-		syncedAt: todayIsoDate(),
-		generator: "skilld"
-	});
-	writeGeneratedSkillMd(skillDir, {
-		name: packageName,
-		version,
-		releasedAt: resolved.releasedAt,
-		description: resolved.description,
-		relatedSkills: [],
-		hasIssues: resources.hasIssues,
-		hasDiscussions: resources.hasDiscussions,
-		hasReleases: resources.hasReleases,
-		hasChangelog,
-		docsType: resources.docsType,
-		hasShippedDocs: shippedDocs,
-		pkgFiles,
-		dirName: skillDirName,
-		repoUrl,
+		skillDir,
+		skillDirName,
+		resources,
+		prepared,
+		resolved,
+		packages: allPackages,
 		features
 	});
-	p.log.success(`Created base skill: ${relative(cwd, skillDir)}`);
-	if (!readConfig().skipLlm && (!yes || opts.model)) {
-		const llmConfig = await selectLlmConfig(opts.model);
-		if (llmConfig?.promptOnly) writePromptFiles({
-			packageName,
+	ctx.overheadLines = writeBaseSkill(ctx, { eject: isEject }).split("\n").length;
+	await hooks.callHook("base:done", {
+		spec,
+		skillDir: relative(cwd, skillDir),
+		mode: config.mode === "update" ? "update" : "add"
+	});
+	const allSectionsCached = !config.force && applyCachedSections(ctx, defaultSections, { eject: isEject });
+	if (allSectionsCached) await hooks.callHook("sections:cached", { spec });
+	return {
+		kind: "ready",
+		state: {
+			ctx,
 			skillDir,
+			skillDirName,
+			baseDir,
+			updateCtx,
+			allSectionsCached,
+			identityName,
+			storageName,
 			version,
-			hasIssues: resources.hasIssues,
-			hasDiscussions: resources.hasDiscussions,
-			hasReleases: resources.hasReleases,
-			hasChangelog,
 			docsType: resources.docsType,
-			hasShippedDocs: shippedDocs,
-			pkgFiles,
-			sections: llmConfig.sections,
-			customPrompt: llmConfig.customPrompt,
-			features
+			repoInfo: resources.repoInfo
+		}
+	};
+}
+async function runEnhancePhase(state, llmConfig, config, hooks, cwd) {
+	const isEject = !!config.eject;
+	const spec = state.identityName;
+	if (llmConfig?.promptOnly) writePromptFiles({
+		...state.ctx,
+		packageName: state.ctx.cachePackageName ?? state.ctx.packageName,
+		cachePackageName: void 0
+	}, {
+		sections: llmConfig.sections,
+		customPrompt: llmConfig.customPrompt
+	});
+	else if (llmConfig) await enhanceWithHooks(state.ctx, llmConfig, {
+		...config,
+		eject: isEject
+	}, hooks, spec);
+	if (isEject) {
+		const cache = createReferenceCache(state.storageName, state.version);
+		if (!config.debug) cache.clearSkillInternal(state.skillDir);
+		cache.eject(state.skillDir, cwd, state.docsType, {
+			features: state.ctx.features ?? getActiveFeatures(),
+			repoInfo: state.repoInfo
 		});
-		else if (llmConfig) {
-			p.log.step(getModelLabel(llmConfig.model));
-			await enhanceSkillWithLLM({
-				packageName,
-				version,
-				skillDir,
-				dirName: skillDirName,
-				model: llmConfig.model,
-				resolved,
-				relatedSkills: [],
-				hasIssues: resources.hasIssues,
-				hasDiscussions: resources.hasDiscussions,
-				hasReleases: resources.hasReleases,
-				hasChangelog,
-				docsType: resources.docsType,
-				hasShippedDocs: shippedDocs,
-				pkgFiles,
-				force: opts.force,
-				debug: opts.debug,
-				sections: llmConfig.sections,
-				customPrompt: llmConfig.customPrompt,
-				features
-			});
+		return;
+	}
+	const shared = config.global ? false : getSharedSkillsDir(cwd) ?? false;
+	if (shared) linkSkillToAgents(state.skillDirName, shared, cwd, config.agent);
+	await ensureProjectFiles({
+		cwd,
+		agent: config.agent,
+		global: config.global,
+		shared
+	});
+}
+async function enhanceWithHooks(ctx, llmConfig, config, hooks, spec) {
+	await hooks.callHook("enhance:start", {
+		spec,
+		modelLabel: getModelLabel(llmConfig.model)
+	});
+	const result = await runSkillEnhancement(ctx, {
+		model: llmConfig.model,
+		force: config.force,
+		debug: config.debug,
+		sections: llmConfig.sections,
+		customPrompt: llmConfig.customPrompt,
+		eject: !!config.eject
+	}, (progress) => hooks.callHook("enhance:progress", {
+		spec,
+		progress
+	}));
+	if (result.wasOptimized) await hooks.callHook("enhance:done", {
+		spec,
+		usage: result.usage ? { totalTokens: result.usage.totalTokens } : void 0,
+		cost: result.cost,
+		debugLogsDir: result.debugLogsDir,
+		error: result.error,
+		warnings: result.warnings
+	});
+	else await hooks.callHook("enhance:failed", {
+		spec,
+		error: result.error ?? "",
+		rateLimited: !!result.error && RATE_LIMIT_RE.test(result.error)
+	});
+}
+function createSyncRun(opts) {
+	const hooks = createHooks();
+	async function runBase(spec) {
+		const result = await runBaseSync(spec, {
+			agent: opts.agent,
+			global: opts.global,
+			mode: opts.mode,
+			force: opts.force,
+			noSearch: opts.noSearch,
+			name: opts.name,
+			from: opts.from,
+			eject: opts.eject
+		}, hooks, opts.resolver, opts.cwd, opts.defaultSections);
+		if (result.kind === "shipped") return {
+			kind: "shipped",
+			spec
+		};
+		if (result.kind === "unresolved") return {
+			kind: "unresolved",
+			spec,
+			identityName: result.unresolved.identityName,
+			attempts: result.unresolved.attempts
+		};
+		if (result.kind === "merge-needed") {
+			if (opts.onMergeNeeded) {
+				await opts.onMergeNeeded(result.state);
+				return {
+					kind: "merged",
+					spec
+				};
+			}
+			return {
+				kind: "error",
+				spec,
+				reason: `Skill dir already holds ${result.state.existingLock.packageName} — run sequentially to merge`
+			};
 		}
+		return {
+			kind: "ready",
+			spec,
+			state: result.state
+		};
 	}
-	const shared = !isGlobal && getSharedSkillsDir(cwd);
-	if (shared) linkSkillToAgents(skillDirName, shared, cwd, agent);
-	if (!isGlobal) {
-		registerProject(cwd);
-		await ensureGitignore(shared || targets[agent].skillsDir, cwd, isGlobal);
-		await ensureAgentInstructions(agent, cwd, isGlobal);
+	async function runEnhance(state, llmConfig) {
+		await runEnhancePhase(state, llmConfig, {
+			agent: opts.agent,
+			global: opts.global,
+			force: opts.force,
+			debug: opts.debug,
+			eject: opts.eject
+		}, hooks, opts.cwd);
+	}
+	async function run(spec) {
+		const base = await runBase(spec);
+		if (base.kind !== "ready") return base;
+		let llmConfig = null;
+		if (!base.state.allSectionsCached && opts.resolveLlmConfig) llmConfig = await opts.resolveLlmConfig({ ready: [{
+			spec,
+			state: base.state
+		}] }) ?? null;
+		await runEnhance(base.state, llmConfig);
+		return {
+			kind: "enhanced",
+			spec,
+			state: base.state
+		};
 	}
-	await shutdownWorker();
-	track({
-		event: "install",
-		source: `${owner}/${repo}`,
-		skills: skillDirName,
-		agents: agent,
-		...isGlobal && { global: "1" },
-		sourceType: "github-generated"
+	async function runMany(specs, runOpts) {
+		const limit = pLimit(runOpts?.concurrency ?? 5);
+		return (await Promise.allSettled(specs.map((spec) => limit(() => runBase(spec))))).map((r, i) => r.status === "fulfilled" ? r.value : {
+			kind: "error",
+			spec: specs[i],
+			reason: r.reason instanceof Error ? r.reason.message : String(r.reason)
+		});
+	}
+	return {
+		hooks,
+		runBase,
+		runEnhance,
+		run,
+		runMany
+	};
+}
+function bindClackUi(hooks, { cwd }) {
+	let spinner = null;
+	let resourceSpinner = null;
+	let indexSpinner = null;
+	let llmLog = null;
+	let currentSpec = "";
+	hooks.hook("resolve:start", ({ spec }) => {
+		currentSpec = spec;
+		spinner = timedSpinner();
+		spinner.start(`Resolving ${spec}`);
+	});
+	hooks.hook("resolve:progress", ({ message }) => {
+		spinner?.message(message);
+	});
+	hooks.hook("resolve:done", ({ version, cached, force }) => {
+		const suffix = force ? " (force)" : cached ? " (cached)" : "";
+		spinner?.stop(`Resolved ${currentSpec}@${version}${suffix}`);
+		spinner = null;
+	});
+	hooks.hook("resolve:failed", ({ identityName }) => {
+		spinner?.stop(`Could not find docs for: ${identityName}`);
+		spinner = null;
+	});
+	hooks.hook("dist:downloading", () => {
+		spinner?.message("Downloading dist");
+	});
+	hooks.hook("fetch:start", () => {
+		resourceSpinner = timedSpinner();
+		resourceSpinner.start("Finding resources");
+	});
+	hooks.hook("fetch:progress", ({ message }) => {
+		resourceSpinner?.message(message);
+	});
+	hooks.hook("fetch:done", ({ parts, cached }) => {
+		const summary = parts.length > 0 ? parts.join(", ") : "resources";
+		resourceSpinner?.stop(cached ? `Loaded ${summary} (cached)` : `Fetched ${summary}`);
+		resourceSpinner = null;
+	});
+	hooks.hook("index:start", () => {
+		indexSpinner = timedSpinner();
+		indexSpinner.start("Creating search index");
+	});
+	hooks.hook("index:progress", ({ message }) => {
+		indexSpinner?.message(message);
+	});
+	hooks.hook("index:done", () => {
+		indexSpinner?.stop("Search index ready");
+		indexSpinner = null;
+	});
+	hooks.hook("warn", ({ message }) => {
+		p.log.warn(styleText("yellow", message));
+	});
+	hooks.hook("base:done", ({ skillDir, mode }) => {
+		p.log.success(mode === "update" ? `Updated skill: ${skillDir}` : `Created base skill: ${skillDir}`);
+	});
+	hooks.hook("sections:cached", () => {
+		p.log.success("Applied cached SKILL.md sections");
+	});
+	hooks.hook("enhance:start", ({ spec, modelLabel }) => {
+		currentSpec = spec;
+		p.log.step(modelLabel);
+		llmLog = p.taskLog({
+			title: `Agent exploring ${spec}`,
+			limit: 3
+		});
+	});
+	hooks.hook("enhance:progress", ({ progress }) => {
+		if (!llmLog) return;
+		const line = `${progress.section ? `[${progress.section}] ` : ""}${progress.chunk}`;
+		llmLog.message(line);
+	});
+	hooks.hook("enhance:done", (info) => {
+		if (!llmLog) return;
+		const parts = [];
+		if (info.usage) parts.push(`${Math.round(info.usage.totalTokens / 1e3)}k tokens`);
+		if (info.cost) parts.push(`$${info.cost.toFixed(2)}`);
+		const suffix = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+		llmLog.success(`Generated best practices${suffix}`);
+		llmLog = null;
+		if (info.debugLogsDir) p.log.info(`Debug logs: ${relative(cwd, info.debugLogsDir)}`);
+		if (info.error) p.log.warn(styleText("yellow", `Partial failure: ${info.error}`));
+		if (info.warnings) for (const w of info.warnings) p.log.warn(styleText("yellow", w));
+	});
+	hooks.hook("enhance:failed", ({ error, rateLimited }) => {
+		if (!llmLog) return;
+		if (rateLimited) llmLog.error(`Rate limited by LLM provider. Try again shortly or use a different model via \`skilld config\``);
+		else llmLog.error(`Enhancement failed${error ? `: ${error}` : ""}`);
+		llmLog = null;
+	});
+	hooks.hook("shipped:installed", ({ skillName, skillDir }) => {
+		p.log.success(`Using published SKILL.md: ${skillName} → ${relative(cwd, skillDir)}`);
 	});
-	p.outro(`Synced ${owner}/${repo} to ${relative(cwd, skillDir)}`);
 }
 const STATUS_ICONS = {
 	pending: "○",
@@ -274,419 +527,290 @@ const STATUS_ICONS = {
 	error: "✗"
 };
 const STATUS_COLORS = {
-	pending: "\x1B[90m",
-	resolving: "\x1B[36m",
-	downloading: "\x1B[36m",
-	embedding: "\x1B[36m",
-	exploring: "\x1B[34m",
-	thinking: "\x1B[35m",
-	generating: "\x1B[33m",
-	done: "\x1B[32m",
-	error: "\x1B[31m"
+	pending: "gray",
+	resolving: "cyan",
+	downloading: "cyan",
+	embedding: "cyan",
+	exploring: "blue",
+	thinking: "magenta",
+	generating: "yellow",
+	done: "green",
+	error: "red"
 };
-async function syncPackagesParallel(config) {
-	const { packages, concurrency = 5 } = config;
-	const agent = targets[config.agent];
-	const states = /* @__PURE__ */ new Map();
-	const cwd = process.cwd();
-	for (const pkg of packages) states.set(pkg, {
-		name: pkg,
-		status: "pending",
-		message: "Waiting..."
+function renderParallel(r) {
+	const maxNameLen = Math.max(...[...r.states.keys()].map((n) => n.length), 20);
+	const lines = [...r.states.values()].map((s) => {
+		const icon = styleText(STATUS_COLORS[s.status], STATUS_ICONS[s.status]);
+		const name = s.name.padEnd(maxNameLen);
+		const version = s.version ? `${styleText("gray", s.version)} ` : "";
+		const elapsed = (s.status === "done" || s.status === "error") && s.startedAt && s.completedAt ? ` ${styleText("gray", `(${formatDuration(s.completedAt - s.startedAt)})`)}` : "";
+		const preview = s.streamPreview ? ` ${styleText("gray", s.streamPreview)}` : "";
+		return `  ${icon} ${name} ${version}${s.message}${elapsed}${preview}`;
 	});
-	function render() {
-		const maxNameLen = Math.max(...packages.map((p) => p.length), 20);
-		const lines = Array.from(states.values(), (s) => {
-			const icon = STATUS_ICONS[s.status];
-			const color = STATUS_COLORS[s.status];
-			const reset = "\x1B[0m";
-			const dim = "\x1B[90m";
-			const name = s.name.padEnd(maxNameLen);
-			const version = s.version ? `${dim}${s.version}${reset} ` : "";
-			const elapsed = (s.status === "done" || s.status === "error") && s.startedAt && s.completedAt ? ` ${dim}(${formatDuration(s.completedAt - s.startedAt)})${reset}` : "";
-			const preview = s.streamPreview ? ` ${dim}${s.streamPreview}${reset}` : "";
-			return `  ${color}${icon}${reset} ${name} ${version}${s.message}${elapsed}${preview}`;
-		});
-		const doneCount = [...states.values()].filter((s) => s.status === "done").length;
-		const errorCount = [...states.values()].filter((s) => s.status === "error").length;
-		logUpdate(`\x1B[1m${config.mode === "update" ? "Updating" : "Syncing"} ${packages.length} packages\x1B[0m (${doneCount} done${errorCount > 0 ? `, ${errorCount} failed` : ""})\n` + lines.join("\n"));
-	}
-	function update(pkg, status, message, version) {
-		const state = states.get(pkg);
+	const doneCount = [...r.states.values()].filter((s) => s.status === "done").length;
+	const errorCount = [...r.states.values()].filter((s) => s.status === "error").length;
+	logUpdate(`${styleText("bold", `${r.verb} ${r.total} packages`)} (${doneCount} done${errorCount > 0 ? `, ${errorCount} failed` : ""})\n` + lines.join("\n"));
+}
+function bindParallelUi(hooks, render) {
+	function update(spec, status, message, ver) {
+		const state = render.states.get(spec);
+		if (!state) return;
 		if (!state.startedAt && status !== "pending") state.startedAt = performance.now();
 		if ((status === "done" || status === "error") && !state.completedAt) state.completedAt = performance.now();
 		state.status = status;
 		state.message = message;
 		state.streamPreview = void 0;
-		if (version) state.version = version;
-		render();
+		if (ver) state.version = ver;
+		renderParallel(render);
 	}
+	hooks.hook("resolve:start", ({ spec }) => update(spec, "resolving", "Resolving..."));
+	hooks.hook("resolve:progress", ({ spec, message }) => update(spec, "resolving", message));
+	hooks.hook("resolve:done", ({ spec, version, cached, force }) => {
+		update(spec, "downloading", cached ? "Using cache" : force ? "Re-fetching docs..." : "Fetching docs...", version);
+	});
+	hooks.hook("resolve:failed", () => {});
+	hooks.hook("dist:downloading", ({ spec }) => update(spec, "downloading", "Downloading dist..."));
+	hooks.hook("fetch:start", () => {});
+	hooks.hook("fetch:progress", ({ spec, message }) => update(spec, "downloading", message));
+	hooks.hook("fetch:done", ({ spec }) => update(spec, "downloading", "Linking references..."));
+	hooks.hook("index:start", ({ spec }) => update(spec, "embedding", "Indexing docs"));
+	hooks.hook("index:progress", ({ spec, message }) => update(spec, "embedding", message));
+	hooks.hook("index:done", () => {});
+	hooks.hook("warn", () => {});
+	hooks.hook("base:done", ({ spec, mode }) => {
+		update(spec, "done", mode === "update" ? "Skill updated" : "Base skill created");
+	});
+	hooks.hook("sections:cached", () => {});
+	hooks.hook("enhance:start", ({ spec, modelLabel }) => update(spec, "generating", modelLabel));
+	hooks.hook("enhance:progress", ({ spec, progress }) => {
+		update(spec, progress.type === "reasoning" ? "exploring" : "generating", `${progress.section ? `[${progress.section}] ` : ""}${progress.chunk}`);
+	});
+	hooks.hook("enhance:done", ({ spec }) => update(spec, "done", "Skill optimized"));
+	hooks.hook("enhance:failed", ({ spec, error }) => update(spec, "error", error));
+	hooks.hook("shipped:installed", ({ spec }) => update(spec, "done", "Published SKILL.md"));
+}
+const DIFF_RANK = {
+	major: 5,
+	premajor: 4,
+	minor: 3,
+	preminor: 2,
+	patch: 1,
+	prepatch: 1,
+	prerelease: 0
+};
+async function syncPackagesParallel(config) {
+	const { packages, concurrency = 5 } = config;
+	const cwd = process.cwd();
+	const states = /* @__PURE__ */ new Map();
+	const specToName = /* @__PURE__ */ new Map();
+	for (const spec of packages) {
+		const { name } = parsePackageSpec(spec);
+		specToName.set(spec, name);
+		states.set(spec, {
+			name,
+			status: "pending",
+			message: "Waiting..."
+		});
+	}
+	const render = {
+		states,
+		verb: config.mode === "update" ? "Updating" : "Syncing",
+		total: packages.length
+	};
 	ensureCacheDir();
-	render();
+	renderParallel(render);
+	const run = createSyncRun({
+		cwd,
+		resolver: npmResolver,
+		agent: config.agent,
+		global: config.global,
+		mode: config.mode,
+		force: config.force,
+		debug: config.debug,
+		defaultSections: DEFAULT_SECTIONS
+	});
+	bindParallelUi(run.hooks, render);
 	const limit = pLimit(concurrency);
-	const skillData = /* @__PURE__ */ new Map();
-	const baseResults = await Promise.allSettled(packages.map((pkg) => limit(() => syncBaseSkill(pkg, config, cwd, update))));
+	const baseResults = await Promise.allSettled(packages.map((spec) => limit(() => run.runBase(spec))));
 	logUpdate.done();
-	const successfulPkgs = [];
-	const shippedPkgs = [];
+	const ready = [];
+	const shippedCount = [];
 	const errors = [];
+	const aggregatedWarnings = [];
 	for (let i = 0; i < baseResults.length; i++) {
+		const spec = packages[i];
 		const r = baseResults[i];
-		if (r.status === "fulfilled" && r.value !== "shipped") {
-			successfulPkgs.push(packages[i]);
-			skillData.set(packages[i], r.value);
-		} else if (r.status === "fulfilled" && r.value === "shipped") shippedPkgs.push(packages[i]);
-		else if (r.status === "rejected") {
+		if (r.status === "rejected") {
 			const err = r.reason;
-			const reason = err instanceof Error ? `${err.message}\n${err.stack}` : String(err);
+			const reason = err instanceof Error ? err.message : String(err);
+			const slot = states.get(spec);
+			if (slot) slot.status = "error";
 			errors.push({
-				pkg: packages[i],
+				spec,
 				reason
 			});
-		}
-	}
-	const pastVerb = config.mode === "update" ? "Updated" : "Created";
-	const skillMsg = `${pastVerb} ${successfulPkgs.length} base skills${shippedPkgs.length > 1 ? ` (Skipping ${shippedPkgs.length})` : ""}`;
-	p.log.success(skillMsg);
-	for (const [, data] of skillData) for (const w of data.warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
-	if (errors.length > 0) for (const { pkg, reason } of errors) p.log.error(`  ${pkg}: ${reason}`);
-	const cachedPkgs = [];
-	if (!config.force) for (const pkg of successfulPkgs) {
-		const data = skillData.get(pkg);
-		const resolvedName = data.resolved.name;
-		if (DEFAULT_SECTIONS.every((s) => {
-			const outputFile = SECTION_OUTPUT_FILES[s];
-			return readCachedSection(resolvedName, data.version, outputFile) !== null;
-		})) {
-			const skillDir = join(resolveBaseDir(cwd, config.agent, config.global), data.skillDirName);
-			const cachedParts = [];
-			for (const s of SECTION_MERGE_ORDER) {
-				if (!DEFAULT_SECTIONS.includes(s)) continue;
-				const outputFile = SECTION_OUTPUT_FILES[s];
-				const content = readCachedSection(resolvedName, data.version, outputFile);
-				if (content) cachedParts.push(wrapSection(s, content));
+			continue;
+		}
+		const result = r.value;
+		if (result.kind === "shipped") {
+			shippedCount.push(spec);
+			continue;
+		}
+		if (result.kind === "unresolved") {
+			const npmAttempt = result.attempts.find((a) => a.source === "npm");
+			let reason;
+			if (npmAttempt?.status === "not-found") {
+				const suggestions = await searchNpmPackages(result.identityName, 3);
+				const hint = suggestions.length > 0 ? ` (try: ${suggestions.map((s) => s.name).join(", ")})` : "";
+				reason = (npmAttempt.message || "Not on npm") + hint;
+			} else reason = result.attempts.filter((a) => a.status !== "success").map((a) => a.message || a.source).join("; ") || "No docs found";
+			const slot = states.get(spec);
+			if (slot) {
+				slot.status = "error";
+				slot.message = reason;
 			}
-			const cachedBody = cachedParts.join("\n\n");
-			writeGeneratedSkillMd(skillDir, {
-				name: resolvedName,
-				version: data.version,
-				releasedAt: data.resolved.releasedAt,
-				distTags: data.resolved.distTags,
-				body: cachedBody,
-				relatedSkills: data.relatedSkills,
-				hasIssues: data.hasIssues,
-				hasDiscussions: data.hasDiscussions,
-				hasReleases: data.hasReleases,
-				hasChangelog: data.hasChangelog,
-				docsType: data.docsType,
-				hasShippedDocs: data.shippedDocs,
-				pkgFiles: data.pkgFiles,
-				generatedBy: "cached",
-				dirName: data.skillDirName,
-				packages: data.packages,
-				repoUrl: data.resolved.repoUrl,
-				features: data.features
+			errors.push({
+				spec,
+				reason
+			});
+			continue;
+		}
+		if (result.kind === "error") {
+			errors.push({
+				spec,
+				reason: result.reason
 			});
-			cachedPkgs.push(pkg);
+			continue;
 		}
+		if (result.kind === "ready") ready.push({
+			spec,
+			state: result.state
+		});
 	}
-	const uncachedPkgs = successfulPkgs.filter((pkg) => !cachedPkgs.includes(pkg));
+	renderParallel(render);
+	logUpdate.done();
+	const pastVerb = config.mode === "update" ? "Updated" : "Created";
+	p.log.success(`${pastVerb} ${ready.length} base skills${shippedCount.length > 0 ? ` (${shippedCount.length} shipped)` : ""}`);
+	for (const w of aggregatedWarnings) p.log.warn(styleText("yellow", w));
+	for (const { spec, reason } of errors) p.log.error(`  ${spec}: ${reason}`);
+	const cachedPkgs = [];
+	const uncached = [];
+	for (const r of ready) if (r.state.allSectionsCached) cachedPkgs.push(r.spec);
+	else uncached.push(r);
 	if (cachedPkgs.length > 0) p.log.success(`Applied cached SKILL.md sections for ${cachedPkgs.join(", ")}`);
 	const globalConfig = readConfig();
-	let resolvedModel = config.model || (config.yes && !globalConfig.skipLlm ? globalConfig.model : void 0);
-	if (!resolvedModel && config.yes && !globalConfig.skipLlm) {
-		const { getAvailableModels } = await import("../agent/index.mjs");
-		const available = await getAvailableModels();
-		const auto = available.find((m) => m.recommended)?.id ?? available[0]?.id;
-		if (auto) resolvedModel = auto;
-	}
-	if (uncachedPkgs.length > 0 && !globalConfig.skipLlm && !(config.yes && !resolvedModel)) {
-		const DIFF_RANK = {
-			major: 5,
-			premajor: 4,
-			minor: 3,
-			preminor: 2,
-			patch: 1,
-			prepatch: 1,
-			prerelease: 0
-		};
-		let parallelUpdateCtx;
-		if (config.mode === "update") {
-			let maxDiff = "";
-			let allEnhanced = true;
-			let anySyncedAt;
-			for (const pkg of successfulPkgs) {
-				const data = skillData.get(pkg);
-				if (!data.wasEnhanced) allEnhanced = false;
-				if (data.oldSyncedAt && (!anySyncedAt || data.oldSyncedAt < anySyncedAt)) anySyncedAt = data.oldSyncedAt;
-				if (data.oldVersion) {
-					const diff = semverDiff(data.oldVersion, data.version);
-					if (diff && (DIFF_RANK[diff] ?? 0) > (DIFF_RANK[maxDiff] ?? -1)) maxDiff = diff;
+	const resolvedModel = await resolveAutoModel(config.model, config.yes);
+	if (uncached.length > 0 && !globalConfig.skipLlm && !(config.yes && !resolvedModel)) {
+		const llmConfig = await selectLlmConfig(resolvedModel, void 0, config.mode === "update" ? aggregateUpdateCtx(uncached) : void 0);
+		if (llmConfig?.promptOnly) {
+			for (const r of uncached) {
+				const slot = states.get(r.spec);
+				if (slot) {
+					slot.status = "done";
+					slot.message = "Prompts written";
 				}
 			}
-			const first = skillData.get(successfulPkgs[0]);
-			parallelUpdateCtx = {
-				oldVersion: successfulPkgs.length === 1 ? first.oldVersion : void 0,
-				newVersion: successfulPkgs.length === 1 ? first.version : void 0,
-				syncedAt: anySyncedAt,
-				wasEnhanced: allEnhanced,
-				bumpType: maxDiff || void 0
-			};
-		}
-		const llmConfig = await selectLlmConfig(resolvedModel, void 0, parallelUpdateCtx);
-		if (llmConfig?.promptOnly) for (const pkg of uncachedPkgs) {
-			const data = skillData.get(pkg);
-			writePromptFiles({
-				packageName: pkg,
-				skillDir: join(resolveBaseDir(cwd, config.agent, config.global), data.skillDirName),
-				version: data.version,
-				hasIssues: data.hasIssues,
-				hasDiscussions: data.hasDiscussions,
-				hasReleases: data.hasReleases,
-				hasChangelog: data.hasChangelog,
-				docsType: data.docsType,
-				hasShippedDocs: data.shippedDocs,
-				pkgFiles: data.pkgFiles,
-				sections: llmConfig.sections,
-				customPrompt: llmConfig.customPrompt,
-				features: data.features,
-				overheadLines: data.overheadLines
-			});
-		}
-		else if (llmConfig) {
+			renderParallel(render);
+			for (const r of uncached) await run.runEnhance(r.state, llmConfig);
+		} else if (llmConfig) {
 			p.log.step(getModelLabel(llmConfig.model));
-			for (const pkg of uncachedPkgs) states.set(pkg, {
-				name: pkg,
-				status: "pending",
-				message: "Waiting..."
-			});
-			render();
-			const llmResults = await Promise.allSettled(uncachedPkgs.map((pkg) => limit(() => enhanceWithLLM(pkg, skillData.get(pkg), {
-				...config,
-				model: llmConfig.model
-			}, cwd, update, llmConfig.sections, llmConfig.customPrompt))));
+			for (const r of uncached) {
+				const displayName = specToName.get(r.spec) ?? r.spec;
+				states.set(r.spec, {
+					name: displayName,
+					status: "pending",
+					message: "Waiting...",
+					version: getVersionKey(r.state.version)
+				});
+			}
+			renderParallel(render);
+			const llmResults = await Promise.allSettled(uncached.map((r) => limit(() => run.runEnhance(r.state, llmConfig))));
 			logUpdate.done();
-			const llmSucceeded = llmResults.filter((r) => r.status === "fulfilled").length;
-			p.log.success(`Enhanced ${llmSucceeded}/${uncachedPkgs.length} skills with LLM`);
+			const llmSucceeded = llmResults.filter((x) => x.status === "fulfilled").length;
+			p.log.success(`Enhanced ${llmSucceeded}/${uncached.length} skills with LLM`);
 		}
-	}
-	await ensureGitignore(getSharedSkillsDir(cwd) ? SHARED_SKILLS_DIR : agent.skillsDir, cwd, config.global);
-	await ensureAgentInstructions(config.agent, cwd, config.global);
+	} else for (const r of ready) await run.runEnhance(r.state, null);
+	await ensureProjectFiles({
+		cwd,
+		agent: config.agent,
+		global: config.global
+	});
 	await shutdownWorker();
-	p.outro(`${pastVerb} ${successfulPkgs.length}/${packages.length} packages`);
-	const { suggestPrepareHook } = await import("./cli-helpers2.mjs");
+	p.outro(`${pastVerb} ${ready.length}/${packages.length} packages`);
+	const { suggestPrepareHook } = await import("./prepare-hook.mjs");
 	try {
 		await suggestPrepareHook(cwd);
 	} catch (err) {
 		p.log.warn(`Failed to suggest prepare hook: ${err instanceof Error ? err.message : String(err)}`);
 	}
 }
-async function syncBaseSkill(packageSpec, config, cwd, update) {
-	const { name: packageName, tag: requestedTag } = parsePackageSpec(packageSpec);
-	const localVersion = (await readLocalDependencies(cwd).catch(() => [])).find((d) => d.name === packageName)?.version;
-	const { package: resolvedPkg, attempts, registryVersion } = await resolvePackageDocsWithAttempts(requestedTag ? packageSpec : packageName, {
-		version: localVersion,
+function aggregateUpdateCtx(ready) {
+	let maxDiff = "";
+	let allEnhanced = true;
+	let anySyncedAt;
+	for (const r of ready) {
+		const u = r.state.updateCtx;
+		if (!u?.wasEnhanced) allEnhanced = false;
+		if (u?.syncedAt && (!anySyncedAt || u.syncedAt < anySyncedAt)) anySyncedAt = u.syncedAt;
+		if (u?.oldVersion && u.newVersion) {
+			const diff = semverDiff(u.oldVersion, u.newVersion);
+			if (diff && (DIFF_RANK[diff] ?? 0) > (DIFF_RANK[maxDiff] ?? -1)) maxDiff = diff;
+		}
+	}
+	const first = ready[0]?.state.updateCtx;
+	return {
+		oldVersion: ready.length === 1 ? first?.oldVersion : void 0,
+		newVersion: ready.length === 1 ? first?.newVersion : void 0,
+		syncedAt: anySyncedAt,
+		wasEnhanced: allEnhanced,
+		bumpType: maxDiff || void 0
+	};
+}
+async function handleMerge(state, config, cwd) {
+	const { identityName, storageName, version, resolved, baseDir, skillDir, skillDirName, existingLock } = state;
+	p.log.step(`Merging ${identityName} into ${skillDirName}`);
+	createReferenceCache(storageName, version).linkPkgNamed(skillDir, cwd);
+	const repoSlug = parseGitHubRepoSlug(resolved.repoUrl);
+	installSkill({
 		cwd,
-		onProgress: (step) => update(packageName, "resolving", RESOLVE_STEP_LABELS[step])
-	});
-	let resolved = resolvedPkg;
-	if (!resolved) {
-		update(packageName, "resolving", "Local package...");
-		resolved = await resolveLocalDep(packageName, cwd);
-	}
-	if (!resolved) {
-		const shippedVersion = localVersion || registryVersion || "latest";
-		const earlyShipped = handleShippedSkills(packageName, shippedVersion, cwd, config.agent, config.global);
-		if (earlyShipped) {
-			const shared = !config.global && getSharedSkillsDir(cwd);
-			if (shared) for (const shipped of earlyShipped.shipped) linkSkillToAgents(shipped.skillName, shared, cwd, config.agent);
-			update(packageName, "done", "Published SKILL.md", getVersionKey(shippedVersion));
-			return "shipped";
-		}
-		const npmAttempt = attempts.find((a) => a.source === "npm");
-		let reason;
-		if (npmAttempt?.status === "not-found") {
-			const suggestions = await searchNpmPackages(packageName, 3);
-			const hint = suggestions.length > 0 ? ` (try: ${suggestions.map((s) => s.name).join(", ")})` : "";
-			reason = (npmAttempt.message || "Not on npm") + hint;
-		} else reason = attempts.filter((a) => a.status !== "success").map((a) => a.message || a.source).join("; ") || "No docs found";
-		update(packageName, "error", reason);
-		throw new Error(`Could not find docs for: ${packageName}`);
-	}
-	const version = localVersion || resolved.version || "latest";
-	const versionKey = getVersionKey(version);
-	if (!existsSync(join(cwd, "node_modules", packageName))) {
-		update(packageName, "downloading", "Downloading dist...", versionKey);
-		await fetchPkgDist(packageName, version);
-	}
-	const shippedResult = handleShippedSkills(packageName, version, cwd, config.agent, config.global);
-	if (shippedResult) {
-		const shared = !config.global && getSharedSkillsDir(cwd);
-		if (shared) for (const shipped of shippedResult.shipped) linkSkillToAgents(shipped.skillName, shared, cwd, config.agent);
-		update(packageName, "done", "Published SKILL.md", versionKey);
-		return "shipped";
-	}
-	if (config.force) forceClearCache(packageName, version);
-	const useCache = isCached(packageName, version);
-	if (useCache) update(packageName, "downloading", "Using cache", versionKey);
-	else update(packageName, "downloading", config.force ? "Re-fetching docs..." : "Fetching docs...", versionKey);
-	const baseDir = resolveBaseDir(cwd, config.agent, config.global);
-	let skillDirName = computeSkillDirName(packageName);
-	if (config.mode === "update") {
-		const lock = readLock(baseDir);
-		if (lock) {
-			for (const [name, info] of Object.entries(lock.skills)) if (info.packageName === packageName || parsePackages(info.packages).some((p) => p.name === packageName)) {
-				skillDirName = name;
-				break;
-			}
-		}
-	}
-	const skillDir = join(baseDir, skillDirName);
-	mkdirSync(skillDir, { recursive: true });
-	const preLock = config.mode === "update" ? readLock(baseDir)?.skills[skillDirName] : void 0;
-	const preEnhanced = (() => {
-		if (!preLock) return false;
-		const skillMdPath = join(skillDir, "SKILL.md");
-		if (!existsSync(skillMdPath)) return false;
-		return !!parseFrontmatter(readFileSync(skillMdPath, "utf-8")).generated_by;
-	})();
-	const features = readConfig().features ?? defaultFeatures;
-	const resources = await fetchAndCacheResources({
-		packageName,
-		resolved,
-		version,
-		useCache,
-		features,
-		onProgress: (msg) => update(packageName, "downloading", msg, versionKey)
-	});
-	update(packageName, "downloading", "Linking references...", versionKey);
-	linkAllReferences(skillDir, packageName, cwd, version, resources.docsType, void 0, features, resources.repoInfo);
-	if (features.search) {
-		update(packageName, "embedding", "Indexing docs", versionKey);
-		await indexResources({
-			packageName,
+		agent: config.agent,
+		global: config.global,
+		baseDir,
+		skillDirName,
+		lock: {
+			packageName: identityName,
 			version,
-			cwd,
-			docsToIndex: resources.docsToIndex,
-			features,
-			onProgress: (msg) => update(packageName, "embedding", msg, versionKey)
-		});
-	}
-	const hasChangelog = detectChangelog(resolvePkgDir(packageName, cwd, version), getCacheDir(packageName, version));
-	const relatedSkills = await findRelatedSkills(packageName, baseDir);
-	const shippedDocs = hasShippedDocs(packageName, cwd, version);
-	const pkgFiles = getPkgKeyFiles(packageName, cwd, version);
-	const repoSlug = parseGitHubRepoSlug(resolved.repoUrl);
-	linkPkgNamed(skillDir, packageName, cwd, version);
-	writeLock(baseDir, skillDirName, {
-		packageName,
-		version,
-		repo: repoSlug,
-		source: resources.docSource,
-		syncedAt: todayIsoDate(),
-		generator: "skilld"
+			repo: repoSlug,
+			source: existingLock.source,
+			syncedAt: todayIsoDate(),
+			generator: "skilld"
+		},
+		skipLinkAgents: true
 	});
 	const updatedLock = readLock(baseDir)?.skills[skillDirName];
 	const allPackages = parsePackageNames(updatedLock?.packages);
-	const overheadLines = writeGeneratedSkillMd(skillDir, {
-		name: packageName,
-		version,
-		releasedAt: resolved.releasedAt,
-		description: resolved.description,
-		distTags: resolved.distTags,
+	const relatedSkills = await findRelatedSkills(storageName, baseDir);
+	const existingCache = createReferenceCache(toStoragePackageName(existingLock.packageName), existingLock.version);
+	const pkgFiles = existingCache.keyFiles(cwd);
+	const shippedDocs = existingCache.hasShipped(cwd);
+	const features = getActiveFeatures();
+	writeGeneratedSkillMd(skillDir, {
+		name: existingLock.packageName,
+		version: existingLock.version,
 		relatedSkills,
-		hasIssues: resources.hasIssues,
-		hasDiscussions: resources.hasDiscussions,
-		hasReleases: resources.hasReleases,
-		hasChangelog,
-		docsType: resources.docsType,
+		hasIssues: features.issues && existsSync(skillRefsSection(skillDir, "issues")),
+		hasDiscussions: features.discussions && existsSync(skillRefsSection(skillDir, "discussions")),
+		hasReleases: features.releases && existsSync(skillRefsSection(skillDir, "releases")),
+		docsType: existingLock.source?.includes("llms.txt") ? "llms.txt" : "docs",
 		hasShippedDocs: shippedDocs,
 		pkgFiles,
 		dirName: skillDirName,
-		packages: allPackages.length > 1 ? allPackages : void 0,
-		repoUrl: resolved.repoUrl,
+		packages: allPackages,
 		features
-	}).split("\n").length;
-	const shared = !config.global && getSharedSkillsDir(cwd);
-	if (shared) linkSkillToAgents(skillDirName, shared, cwd, config.agent);
-	if (!config.global) registerProject(cwd);
-	update(packageName, "done", config.mode === "update" ? "Skill updated" : "Base skill created", versionKey);
-	return {
-		resolved,
-		version,
-		skillDirName,
-		docsType: resources.docsType,
-		hasIssues: resources.hasIssues,
-		hasDiscussions: resources.hasDiscussions,
-		hasReleases: resources.hasReleases,
-		hasChangelog,
-		shippedDocs,
-		pkgFiles,
-		relatedSkills,
-		packages: allPackages.length > 1 ? allPackages : void 0,
-		warnings: resources.warnings,
-		features,
-		usedCache: resources.usedCache,
-		oldVersion: preLock?.version,
-		oldSyncedAt: preLock?.syncedAt,
-		wasEnhanced: preEnhanced,
-		overheadLines
-	};
-}
-async function enhanceWithLLM(packageName, data, config, cwd, update, sections, customPrompt) {
-	const versionKey = getVersionKey(data.version);
-	const skillDir = join(resolveBaseDir(cwd, config.agent, config.global), data.skillDirName);
-	const hasGithub = data.hasIssues || data.hasDiscussions;
-	const docFiles = listReferenceFiles(skillDir);
-	update(packageName, "generating", config.model, versionKey);
-	const { optimized, wasOptimized, error } = await optimizeDocs({
-		packageName,
-		skillDir,
-		model: config.model,
-		version: data.version,
-		hasGithub,
-		hasReleases: data.hasReleases,
-		hasChangelog: data.hasChangelog,
-		docFiles,
-		docsType: data.docsType,
-		hasShippedDocs: data.shippedDocs,
-		noCache: config.force,
-		debug: config.debug,
-		sections,
-		customPrompt,
-		features: data.features,
-		pkgFiles: data.pkgFiles,
-		overheadLines: data.overheadLines,
-		onProgress: (progress) => {
-			const status = progress.type === "reasoning" ? "exploring" : "generating";
-			const sectionPrefix = progress.section ? `[${progress.section}] ` : "";
-			update(packageName, status, progress.chunk.startsWith("[") ? `${sectionPrefix}${progress.chunk}` : `${sectionPrefix}${config.model}`, versionKey);
-		}
 	});
-	if (error) {
-		update(packageName, "error", error, versionKey);
-		throw new Error(error);
-	}
-	if (wasOptimized) writeGeneratedSkillMd(skillDir, {
-		name: packageName,
-		version: data.version,
-		releasedAt: data.resolved.releasedAt,
-		distTags: data.resolved.distTags,
-		body: optimized,
-		relatedSkills: data.relatedSkills,
-		hasIssues: data.hasIssues,
-		hasDiscussions: data.hasDiscussions,
-		hasReleases: data.hasReleases,
-		hasChangelog: data.hasChangelog,
-		docsType: data.docsType,
-		hasShippedDocs: data.shippedDocs,
-		pkgFiles: data.pkgFiles,
-		dirName: data.skillDirName,
-		packages: data.packages,
-		repoUrl: data.resolved.repoUrl,
-		features: data.features
-	});
-	update(packageName, "done", "Skill optimized", versionKey);
+	const sharedDir = !config.global && getSharedSkillsDir(cwd);
+	if (sharedDir) linkSkillToAgents(skillDirName, sharedDir, cwd, config.agent);
+	p.outro(`Merged ${identityName} into ${skillDirName}`);
 }
 const RESOLVE_SOURCE_LABELS = {
 	"npm": "npm registry",
@@ -700,20 +824,14 @@ const RESOLVE_SOURCE_LABELS = {
 };
 function showResolveAttempts(attempts) {
 	if (attempts.length === 0) return;
-	p.log.message("\x1B[90mDoc resolution:\x1B[0m");
+	p.log.message(styleText("gray", "Doc resolution:"));
 	for (const attempt of attempts) {
-		const icon = attempt.status === "success" ? "\x1B[32m✓\x1B[0m" : "\x1B[90m✗\x1B[0m";
-		const source = `\x1B[90m${RESOLVE_SOURCE_LABELS[attempt.source] ?? attempt.source}\x1B[0m`;
-		const msg = attempt.message ? ` \x1B[90m— ${attempt.message}\x1B[0m` : "";
+		const icon = attempt.status === "success" ? styleText("green", "✓") : styleText("gray", "✗");
+		const source = styleText("gray", RESOLVE_SOURCE_LABELS[attempt.source] ?? attempt.source);
+		const msg = attempt.message ? ` ${styleText("gray", `— ${attempt.message}`)}` : "";
 		p.log.message(`  ${icon} ${source}${msg}`);
 	}
 }
-function isCrateSpec(spec) {
-	return spec.startsWith("crate:");
-}
-function toCrateIdentity(crateName) {
-	return `crate:${crateName}`;
-}
 async function syncCommand(state, opts) {
 	if (opts.packages && opts.packages.length > 0) {
 		const crateSpecs = opts.packages.filter(isCrateSpec);
@@ -805,52 +923,38 @@ async function pickFromList(packages, state) {
 	}
 	return selected;
 }
-async function syncSinglePackage(packageSpec, config) {
-	const isCrate = isCrateSpec(packageSpec);
-	const normalizedSpec = isCrate ? packageSpec.slice(6).trim() : packageSpec;
-	if (isCrate && !normalizedSpec) {
-		p.log.error("Invalid crate spec. Use format: crate:<name>");
-		return;
-	}
-	const { name: parsedName, tag: requestedTag } = parsePackageSpec(normalizedSpec);
-	const packageName = isCrate ? parsedName.toLowerCase() : parsedName;
-	const identityPackageName = isCrate ? toCrateIdentity(packageName) : packageName;
-	const storagePackageName = toStoragePackageName(identityPackageName);
-	const spin = timedSpinner();
-	spin.start(`Resolving ${packageSpec}`);
+async function runSimpleSync(packageSpec, config) {
 	const cwd = process.cwd();
-	const localDeps = isCrate ? [] : await readLocalDependencies(cwd).catch(() => []);
-	const localVersion = isCrate ? void 0 : localDeps.find((d) => d.name === packageName)?.version;
-	const resolveResult = isCrate ? await resolveCrateDocsWithAttempts(packageName, {
-		version: requestedTag,
-		onProgress: (step) => spin.message(`${identityPackageName}: ${step}`)
-	}) : await resolvePackageDocsWithAttempts(requestedTag ? normalizedSpec : packageName, {
-		version: localVersion,
+	const isEject = !!config.eject;
+	const run = createSyncRun({
 		cwd,
-		onProgress: (step) => spin.message(`${packageName}: ${RESOLVE_STEP_LABELS[step]}`)
+		resolver: npmResolver,
+		agent: config.agent,
+		global: config.global,
+		mode: config.mode,
+		force: config.force,
+		noSearch: config.noSearch,
+		name: config.name,
+		from: config.from,
+		debug: config.debug,
+		eject: config.eject,
+		defaultSections: DEFAULT_SECTIONS,
+		onMergeNeeded: (state) => handleMerge(state, {
+			agent: config.agent,
+			global: config.global
+		}, cwd)
 	});
-	let resolved = resolveResult.package;
-	if (!resolved && !isCrate) {
-		spin.message(`Resolving local package: ${packageName}`);
-		resolved = await resolveLocalDep(packageName, cwd);
+	bindClackUi(run.hooks, { cwd });
+	const base = await run.runBase(packageSpec);
+	if (base.kind === "shipped") {
+		p.outro(`Synced ${packageSpec}`);
+		return;
 	}
-	if (!resolved) {
-		if (!isCrate) {
-			const earlyShipped = handleShippedSkills(packageName, localVersion || resolveResult.registryVersion || "latest", cwd, config.agent, config.global);
-			if (earlyShipped) {
-				const shared = !config.global && getSharedSkillsDir(cwd);
-				for (const shipped of earlyShipped.shipped) {
-					if (shared) linkSkillToAgents(shipped.skillName, shared, cwd, config.agent);
-					p.log.success(`Using published SKILL.md: ${shipped.skillName} → ${relative(cwd, shipped.skillDir)}`);
-				}
-				spin.stop(`Using published SKILL.md(s) from ${packageName}`);
-				return;
-			}
-			spin.message(`Searching npm for "${packageName}"...`);
-			const suggestions = await searchNpmPackages(packageName);
+	if (base.kind === "unresolved") {
+		if (!isCrateSpec(packageSpec)) {
+			const suggestions = await searchNpmPackages(base.identityName);
 			if (suggestions.length > 0) {
-				spin.stop(`Package "${packageName}" not found on npm`);
-				showResolveAttempts(resolveResult.attempts);
+				showResolveAttempts(base.attempts);
 				const selected = await p.select({
 					message: "Did you mean one of these?",
 					options: [...suggestions.map((s) => ({
@@ -866,725 +970,33 @@ async function syncSinglePackage(packageSpec, config) {
 				return;
 			}
 		}
-		spin.stop(`Could not find docs for: ${identityPackageName}`);
-		showResolveAttempts(resolveResult.attempts);
-		return;
-	}
-	const version = isCrate ? resolved.version || requestedTag || "latest" : localVersion || resolved.version || "latest";
-	const versionKey = getVersionKey(version);
-	if (config.force) forceClearCache(storagePackageName, version);
-	const useCache = isCached(storagePackageName, version);
-	if (!isCrate && !existsSync(join(cwd, "node_modules", packageName))) {
-		spin.message(`Downloading ${packageName}@${version} dist`);
-		await fetchPkgDist(packageName, version);
-	}
-	const shippedResult = isCrate ? null : handleShippedSkills(packageName, version, cwd, config.agent, config.global);
-	if (shippedResult) {
-		const shared = !config.global && getSharedSkillsDir(cwd);
-		for (const shipped of shippedResult.shipped) {
-			if (shared) linkSkillToAgents(shipped.skillName, shared, cwd, config.agent);
-			p.log.success(`Using published SKILL.md: ${shipped.skillName} → ${relative(cwd, shipped.skillDir)}`);
-		}
-		spin.stop(`Using published SKILL.md(s) from ${packageName}`);
-		return;
-	}
-	spin.stop(`Resolved ${identityPackageName}@${useCache ? versionKey : version}${config.force ? " (force)" : useCache ? " (cached)" : ""}`);
-	if (!isCrate && !localVersion && !requestedTag && !isPrerelease(version)) {
-		const nextTag = resolved.distTags?.next ?? resolved.distTags?.beta ?? resolved.distTags?.alpha;
-		if (nextTag && (!resolved.releasedAt || !nextTag.releasedAt || nextTag.releasedAt > resolved.releasedAt)) p.log.warn(`\x1B[33mNo local dependency found — using latest stable (${version}). Prerelease ${nextTag.version} available: skilld add ${packageName}@beta\x1B[0m`);
-	}
-	ensureCacheDir();
-	const baseDir = resolveBaseDir(cwd, config.agent, config.global);
-	let skillDirName = config.name ? sanitizeName(config.name) : computeSkillDirName(storagePackageName);
-	if (config.mode === "update" && !config.name) {
-		const lock = readLock(baseDir);
-		if (lock) {
-			for (const [name, info] of Object.entries(lock.skills)) if (info.packageName === identityPackageName || parsePackages(info.packages).some((p) => p.name === identityPackageName)) {
-				skillDirName = name;
-				break;
-			}
-		}
-	}
-	const skillDir = config.eject ? typeof config.eject === "string" ? join(resolve(cwd, config.eject), skillDirName) : join(cwd, "skills", skillDirName) : join(baseDir, skillDirName);
-	mkdirSync(skillDir, { recursive: true });
-	const existingLock = config.eject ? void 0 : readLock(baseDir)?.skills[skillDirName];
-	const isMerge = existingLock && existingLock.packageName && existingLock.packageName !== identityPackageName;
-	const updateCtx = config.mode === "update" && existingLock ? {
-		oldVersion: existingLock.version,
-		newVersion: version,
-		syncedAt: existingLock.syncedAt,
-		wasEnhanced: (() => {
-			const skillMdPath = join(skillDir, "SKILL.md");
-			if (!existsSync(skillMdPath)) return false;
-			return !!parseFrontmatter(readFileSync(skillMdPath, "utf-8")).generated_by;
-		})()
-	} : void 0;
-	if (isMerge) {
-		spin.stop(`Merging ${identityPackageName} into ${skillDirName}`);
-		linkPkgNamed(skillDir, storagePackageName, cwd, version);
-		const repoSlug = parseGitHubRepoSlug(resolved.repoUrl);
-		writeLock(baseDir, skillDirName, {
-			packageName: identityPackageName,
-			version,
-			repo: repoSlug,
-			source: existingLock.source,
-			syncedAt: todayIsoDate(),
-			generator: "skilld"
-		});
-		const updatedLock = readLock(baseDir)?.skills[skillDirName];
-		const allPackages = parsePackageNames(updatedLock?.packages);
-		const relatedSkills = await findRelatedSkills(storagePackageName, baseDir);
-		const existingStorageName = toStoragePackageName(existingLock.packageName);
-		const pkgFiles = getPkgKeyFiles(existingStorageName, cwd, existingLock.version);
-		const shippedDocs = hasShippedDocs(existingStorageName, cwd, existingLock.version);
-		const mergeFeatures = readConfig().features ?? defaultFeatures;
-		writeGeneratedSkillMd(skillDir, {
-			name: existingLock.packageName,
-			version: existingLock.version,
-			relatedSkills,
-			hasIssues: mergeFeatures.issues && existsSync(join(skillDir, ".skilld", "issues")),
-			hasDiscussions: mergeFeatures.discussions && existsSync(join(skillDir, ".skilld", "discussions")),
-			hasReleases: mergeFeatures.releases && existsSync(join(skillDir, ".skilld", "releases")),
-			docsType: existingLock.source?.includes("llms.txt") ? "llms.txt" : "docs",
-			hasShippedDocs: shippedDocs,
-			pkgFiles,
-			dirName: skillDirName,
-			packages: allPackages,
-			features: mergeFeatures
-		});
-		const mergeShared = !config.global && getSharedSkillsDir(cwd);
-		if (mergeShared) linkSkillToAgents(skillDirName, mergeShared, cwd, config.agent);
-		if (!config.global) registerProject(cwd);
-		p.outro(`Merged ${identityPackageName} into ${skillDirName}`);
+		showResolveAttempts(base.attempts);
 		return;
 	}
-	const features = { ...readConfig().features ?? defaultFeatures };
-	if (config.noSearch) features.search = false;
-	const resSpin = timedSpinner();
-	resSpin.start("Finding resources");
-	const resources = await fetchAndCacheResources({
-		packageName: storagePackageName,
-		resolved,
-		version,
-		useCache,
-		features,
-		from: config.from,
-		onProgress: (msg) => resSpin.message(msg)
-	});
-	const resParts = [];
-	if (resources.docsToIndex.length > 0) {
-		const docCount = resources.docsToIndex.filter((d) => d.metadata?.type === "doc").length;
-		if (docCount > 0) resParts.push(`${docCount} docs`);
-	}
-	if (resources.hasIssues) resParts.push("issues");
-	if (resources.hasDiscussions) resParts.push("discussions");
-	if (resources.hasReleases) resParts.push("releases");
-	resSpin.stop(resources.usedCache ? `Loaded ${resParts.length > 0 ? resParts.join(", ") : "resources"} (cached)` : `Fetched ${resParts.length > 0 ? resParts.join(", ") : "resources"}`);
-	for (const w of resources.warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
-	linkAllReferences(skillDir, storagePackageName, cwd, version, resources.docsType, void 0, features, resources.repoInfo);
-	if (features.search) {
-		const idxSpin = timedSpinner();
-		idxSpin.start("Creating search index");
-		await indexResources({
-			packageName: storagePackageName,
-			version,
-			cwd,
-			docsToIndex: resources.docsToIndex,
-			features,
-			onProgress: (msg) => idxSpin.message(msg)
-		});
-		idxSpin.stop("Search index ready");
-	}
-	const hasChangelog = detectChangelog(resolvePkgDir(storagePackageName, cwd, version), getCacheDir(storagePackageName, version));
-	const relatedSkills = await findRelatedSkills(storagePackageName, baseDir);
-	const shippedDocs = hasShippedDocs(storagePackageName, cwd, version);
-	const pkgFiles = getPkgKeyFiles(storagePackageName, cwd, version);
-	const repoSlug = parseGitHubRepoSlug(resolved.repoUrl);
-	if (!config.eject) linkPkgNamed(skillDir, storagePackageName, cwd, version);
-	if (!config.eject) {
-		writeLock(baseDir, skillDirName, {
-			packageName: identityPackageName,
-			version,
-			repo: repoSlug,
-			source: resources.docSource,
-			syncedAt: todayIsoDate(),
-			generator: "skilld"
-		});
-		const lock = readLock(baseDir);
-		if (lock) for (const [name, info] of Object.entries(lock.skills)) {
-			if (name === skillDirName) continue;
-			if (info.packageName === identityPackageName || parsePackages(info.packages).some((p) => p.name === identityPackageName)) {
-				removeLockEntry(baseDir, name);
-				const staleDir = join(baseDir, name);
-				if (existsSync(staleDir)) rmSync(staleDir, { recursive: true });
-			}
-		}
-	}
-	const allPackages = parsePackageNames((config.eject ? void 0 : readLock(baseDir)?.skills[skillDirName])?.packages);
-	const isEject = !!config.eject;
-	const overheadLines = writeGeneratedSkillMd(skillDir, {
-		name: identityPackageName,
-		version,
-		releasedAt: resolved.releasedAt,
-		description: resolved.description,
-		distTags: resolved.distTags,
-		relatedSkills,
-		hasIssues: resources.hasIssues,
-		hasDiscussions: resources.hasDiscussions,
-		hasReleases: resources.hasReleases,
-		hasChangelog,
-		docsType: resources.docsType,
-		hasShippedDocs: shippedDocs,
-		pkgFiles,
-		dirName: skillDirName,
-		packages: allPackages.length > 1 ? allPackages : void 0,
-		repoUrl: resolved.repoUrl,
-		features,
-		eject: isEject
-	}).split("\n").length;
-	p.log.success(config.mode === "update" ? `Updated skill: ${relative(cwd, skillDir)}` : `Created base skill: ${relative(cwd, skillDir)}`);
-	const allSectionsCached = !config.force && DEFAULT_SECTIONS.every((s) => {
-		const outputFile = SECTION_OUTPUT_FILES[s];
-		return readCachedSection(storagePackageName, version, outputFile) !== null;
-	});
-	if (allSectionsCached) {
-		const cachedParts = [];
-		for (const s of SECTION_MERGE_ORDER) {
-			if (!DEFAULT_SECTIONS.includes(s)) continue;
-			const outputFile = SECTION_OUTPUT_FILES[s];
-			const content = readCachedSection(storagePackageName, version, outputFile);
-			if (content) cachedParts.push(wrapSection(s, content));
-		}
-		const cachedBody = cachedParts.join("\n\n");
-		writeGeneratedSkillMd(skillDir, {
-			name: identityPackageName,
-			version,
-			releasedAt: resolved.releasedAt,
-			description: resolved.description,
-			distTags: resolved.distTags,
-			body: cachedBody,
-			relatedSkills,
-			hasIssues: resources.hasIssues,
-			hasDiscussions: resources.hasDiscussions,
-			hasReleases: resources.hasReleases,
-			hasChangelog,
-			docsType: resources.docsType,
-			hasShippedDocs: shippedDocs,
-			pkgFiles,
-			generatedBy: "cached",
-			dirName: skillDirName,
-			packages: allPackages.length > 1 ? allPackages : void 0,
-			repoUrl: resolved.repoUrl,
-			features,
-			eject: isEject
-		});
-		p.log.success("Applied cached SKILL.md sections");
-	}
+	if (base.kind === "merged" || base.kind === "error") return;
+	const { state } = base;
 	const globalConfig = readConfig();
-	let resolvedModel = config.model || (config.yes && !globalConfig.skipLlm ? globalConfig.model : void 0);
-	if (!resolvedModel && config.yes && !globalConfig.skipLlm) {
-		const available = await getAvailableModels();
-		const auto = available.find((m) => m.recommended)?.id ?? available[0]?.id;
-		if (auto) resolvedModel = auto;
-	}
-	if (!allSectionsCached && !globalConfig.skipLlm && !(config.yes && !resolvedModel)) {
-		const llmConfig = await selectLlmConfig(resolvedModel, void 0, updateCtx);
-		if (llmConfig?.promptOnly) writePromptFiles({
-			packageName: storagePackageName,
-			skillDir,
-			version,
-			hasIssues: resources.hasIssues,
-			hasDiscussions: resources.hasDiscussions,
-			hasReleases: resources.hasReleases,
-			hasChangelog,
-			docsType: resources.docsType,
-			hasShippedDocs: shippedDocs,
-			pkgFiles,
-			sections: llmConfig.sections,
-			customPrompt: llmConfig.customPrompt,
-			features,
-			overheadLines
-		});
-		else if (llmConfig) {
-			p.log.step(getModelLabel(llmConfig.model));
-			await enhanceSkillWithLLM({
-				packageName: identityPackageName,
-				cachePackageName: storagePackageName,
-				version,
-				skillDir,
-				dirName: skillDirName,
-				model: llmConfig.model,
-				resolved,
-				relatedSkills,
-				hasIssues: resources.hasIssues,
-				hasDiscussions: resources.hasDiscussions,
-				hasReleases: resources.hasReleases,
-				hasChangelog,
-				docsType: resources.docsType,
-				hasShippedDocs: shippedDocs,
-				pkgFiles,
-				force: config.force,
-				debug: config.debug,
-				sections: llmConfig.sections,
-				customPrompt: llmConfig.customPrompt,
-				packages: allPackages.length > 1 ? allPackages : void 0,
-				features,
-				eject: isEject,
-				overheadLines
-			});
-		}
-	}
-	if (isEject) {
-		const skilldDir = join(skillDir, ".skilld");
-		if (existsSync(skilldDir) && !config.debug) rmSync(skilldDir, {
-			recursive: true,
-			force: true
-		});
-		ejectReferences(skillDir, storagePackageName, cwd, version, resources.docsType, features, resources.repoInfo);
-	}
-	if (!isEject) {
-		const shared = !config.global && getSharedSkillsDir(cwd);
-		if (shared) linkSkillToAgents(skillDirName, shared, cwd, config.agent);
-		if (!config.global) registerProject(cwd);
-		await ensureGitignore(shared ? SHARED_SKILLS_DIR : targets[config.agent].skillsDir, cwd, config.global);
-		await ensureAgentInstructions(config.agent, cwd, config.global);
-	}
+	const resolvedModel = await resolveAutoModel(config.model, config.yes);
+	let llmConfig = null;
+	if (!state.allSectionsCached && !globalConfig.skipLlm && !(config.yes && !resolvedModel)) llmConfig = await selectLlmConfig(resolvedModel, void 0, state.updateCtx);
+	await run.runEnhance(state, llmConfig);
 	await shutdownWorker();
 	const ejectMsg = isEject ? " (ejected)" : "";
-	const relDir = relative(cwd, skillDir);
-	p.outro(config.mode === "update" ? `Updated ${identityPackageName}${ejectMsg}` : `Synced ${identityPackageName} → ${relDir}${ejectMsg}`);
+	const relDir = relative(cwd, state.skillDir);
+	p.outro(config.mode === "update" ? `Updated ${state.identityName}${ejectMsg}` : `Synced ${state.identityName} → ${relDir}${ejectMsg}`);
 	try {
 		await suggestPrepareHook(cwd);
 	} catch (err) {
 		p.log.warn(`Failed to suggest prepare hook: ${err instanceof Error ? err.message : String(err)}`);
 	}
 }
-const addCommandDef = defineCommand({
-	meta: {
-		name: "add",
-		description: "Install skills (npm:<pkg>, crate:<name>, gh:<owner/repo>, @<curator>)"
-	},
-	args: {
-		package: {
-			type: "positional",
-			description: "Package(s) to sync (space/comma-separated; npm:<pkg>, crate:<name>, or owner/repo)",
-			required: true
-		},
-		skill: {
-			type: "string",
-			alias: "s",
-			description: "Select specific skills from a git repo (comma-separated)",
-			valueHint: "name"
-		},
-		...sharedArgs
-	},
-	async run({ args }) {
-		const cwd = process.cwd();
-		let agent = resolveAgent(args.agent);
-		if (!agent) {
-			agent = await promptForAgent();
-			if (!agent) return;
-		}
-		const rawInputs = [...new Set([args.package, ...args._ || []].map((s) => s.trim()).filter(Boolean))];
-		if (agent === "none") {
-			const packages = [...new Set(rawInputs.flatMap((s) => s.split(/[,\s]+/)).map((s) => s.trim()).filter(Boolean))];
-			for (const pkg of packages) await exportPortablePrompts(pkg, {
-				force: args.force,
-				agent: "none"
-			});
-			return;
-		}
-		if (!hasCompletedWizard()) await runWizard({ agent });
-		const parsedSources = rawInputs.map(parseSkillInput);
-		const gitSources = [];
-		const npmEntries = [];
-		const crateSpecs = [];
-		const unsupported = [];
-		for (const source of parsedSources) switch (source.type) {
-			case "git":
-				gitSources.push(source.source);
-				break;
-			case "npm":
-				npmEntries.push({
-					name: source.package,
-					spec: source.tag ? `${source.package}@${source.tag}` : source.package
-				});
-				break;
-			case "crate":
-				crateSpecs.push(source.version ? `crate:${source.package}@${source.version}` : `crate:${source.package}`);
-				break;
-			case "bare":
-				p.log.warn(`Bare names are deprecated. Use \x1B[36mnpm:${source.package}\x1B[0m instead.`);
-				npmEntries.push({
-					name: source.package,
-					spec: source.tag ? `${source.package}@${source.tag}` : source.package
-				});
-				break;
-			case "curator":
-				unsupported.push(`@${source.handle} (curator)`);
-				break;
-			case "collection":
-				unsupported.push(`@${source.handle}/${source.name} (collection)`);
-				break;
-			default: throw new Error(`Unhandled SkillSource type: ${JSON.stringify(source)}`);
-		}
-		if (unsupported.length > 0) {
-			p.log.error(`Curator and collection installs are not yet available:\n  ${unsupported.join("\n  ")}\n\nFollow https://skilld.dev for launch updates.`);
-			process.exitCode = 1;
-			if (gitSources.length === 0 && npmEntries.length === 0 && crateSpecs.length === 0) return;
-		}
-		if (gitSources.length > 0) for (const source of gitSources) {
-			const skillFilter = args.skill ? args.skill.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean) : void 0;
-			await syncGitSkills({
-				source,
-				global: args.global,
-				agent,
-				yes: args.yes,
-				model: args.model,
-				force: args.force,
-				debug: args.debug,
-				skillFilter
-			});
-		}
-		if (npmEntries.length > 0) {
-			const { syncRegistrySkill } = await import("./sync-registry.mjs");
-			const seen = /* @__PURE__ */ new Set();
-			const dedupedEntries = npmEntries.filter((e) => {
-				if (seen.has(e.name)) return false;
-				seen.add(e.name);
-				return true;
-			});
-			const fallbackPackages = [];
-			for (const entry of dedupedEntries) {
-				const result = await syncRegistrySkill({
-					packageName: entry.name,
-					agent,
-					cwd
-				});
-				if (result) p.log.success(`Installed \x1B[36m${result.name}\x1B[0m from registry`);
-				else fallbackPackages.push(entry.spec);
-			}
-			if (fallbackPackages.length > 0) {
-				const state = await getProjectState(cwd);
-				p.intro(introLine({
-					state,
-					agentId: agent || void 0
-				}));
-				await syncCommand(state, {
-					packages: [...fallbackPackages, ...crateSpecs],
-					global: args.global,
-					agent,
-					model: args.model,
-					yes: args.yes,
-					force: args.force,
-					debug: args.debug
-				});
-				return;
-			}
-		}
-		if (crateSpecs.length > 0) {
-			const state = await getProjectState(cwd);
-			p.intro(introLine({
-				state,
-				agentId: agent || void 0
-			}));
-			await syncCommand(state, {
-				packages: crateSpecs,
-				global: args.global,
-				agent,
-				model: args.model,
-				yes: args.yes,
-				force: args.force,
-				debug: args.debug
-			});
-		}
-	}
-});
-const ejectCommandDef = defineCommand({
-	meta: {
-		name: "eject",
-		description: "Eject skill with references as real files (portable, no symlinks)"
-	},
-	args: {
-		package: {
-			type: "positional",
-			description: "Package to eject",
-			required: true
-		},
-		name: {
-			type: "string",
-			alias: "n",
-			description: "Custom skill directory name (default: derived from package)"
-		},
-		out: {
-			type: "string",
-			alias: "o",
-			description: "Output directory path override"
-		},
-		from: {
-			type: "string",
-			description: "Collect releases/issues/discussions from this date onward (YYYY-MM-DD)"
-		},
-		search: {
-			type: "boolean",
-			description: "Build search index / embeddings (use --no-search to skip)",
-			default: true
-		},
-		...sharedArgs
-	},
-	async run({ args }) {
-		const cwd = process.cwd();
-		const resolved = resolveAgent(args.agent);
-		const agent = resolved && resolved !== "none" ? resolved : "claude-code";
-		if (!hasCompletedWizard()) await runWizard({ agent });
-		const state = await getProjectState(cwd);
-		p.intro(introLine({
-			state,
-			agentId: agent || void 0
-		}));
-		return syncCommand(state, {
-			packages: [args.package],
-			global: args.global,
-			agent,
-			model: args.model,
-			yes: args.yes,
-			force: args.force,
-			debug: args.debug,
-			eject: args.out || true,
-			name: args.name,
-			from: args.from,
-			noSearch: !args.search
-		});
-	}
-});
-const updateCommandDef = defineCommand({
-	meta: {
-		name: "update",
-		description: "Update outdated skills"
-	},
-	args: {
-		package: {
-			type: "positional",
-			description: "Package(s) to update (space or comma-separated). Without args, syncs all outdated.",
-			required: false
-		},
-		background: {
-			type: "boolean",
-			alias: "b",
-			description: "Run in background (detached process, non-interactive)",
-			default: false
-		},
-		...sharedArgs
-	},
-	async run({ args }) {
-		const cwd = process.cwd();
-		if (args.background) {
-			const { spawn } = await import("node:child_process");
-			const updateArgs = [
-				"update",
-				...args.package ? [args.package] : [],
-				...args.agent ? ["--agent", args.agent] : [],
-				...args.model ? ["--model", args.model] : []
-			];
-			spawn(process.execPath, [process.argv[1], ...updateArgs], {
-				cwd,
-				detached: true,
-				stdio: "ignore"
-			}).unref();
-			return;
-		}
-		const silent = !isInteractive();
-		let agent = resolveAgent(args.agent);
-		if (!agent) {
-			agent = await promptForAgent();
-			if (!agent) return;
-		}
-		if (agent === "none") {
-			const state = await getProjectState(cwd);
-			const packages = args.package ? Array.from(new Set([args.package, ...args._ || []].flatMap((s) => s.split(/[,\s]+/)).map((s) => s.trim()).filter(Boolean)), (s) => resolveSkillName(s)).filter((s) => s !== null) : state.outdated.map((s) => s.packageName || s.name);
-			if (packages.length === 0) {
-				if (!silent) p.log.success("All skills up to date");
-				return;
-			}
-			for (const pkg of packages) await exportPortablePrompts(pkg, {
-				force: args.force,
-				agent: "none"
-			});
-			return;
-		}
-		const config = readConfig();
-		const state = await getProjectState(cwd);
-		if (!silent) {
-			const generators = getInstalledGenerators();
-			p.intro(introLine({
-				state,
-				generators,
-				modelId: config.model,
-				agentId: config.agent || agent || void 0
-			}));
-		}
-		if (args.package) {
-			const raw = [...new Set([args.package, ...args._ || []].flatMap((s) => s.split(/[,\s]+/)).map((s) => s.trim()).filter(Boolean))];
-			const packages = [];
-			for (const r of raw) {
-				const name = resolveSkillName(r);
-				if (!name) {
-					p.log.warn(`Cannot update \x1B[36m${r}\x1B[0m: curator/collection inputs are not addressable here.`);
-					continue;
-				}
-				packages.push(name);
-			}
-			if (packages.length === 0) return;
-			return syncCommand(state, {
-				packages,
-				global: args.global,
-				agent,
-				model: args.model || (silent ? config.model : void 0),
-				yes: args.yes || silent,
-				force: args.force,
-				debug: args.debug,
-				mode: "update"
-			});
-		}
-		const crateSpecs = state.skills.map((s) => s.info?.packageName).filter((name) => !!name && name.startsWith("crate:"));
-		if (state.outdated.length === 0 && crateSpecs.length === 0) {
-			p.log.success("All skills up to date");
-			return;
-		}
-		return syncCommand(state, {
-			packages: [...state.outdated.map((s) => s.packageName || s.name), ...crateSpecs],
-			global: args.global,
-			agent,
-			model: args.model || (silent ? config.model : void 0),
-			yes: args.yes || silent,
-			force: args.force,
-			debug: args.debug,
-			mode: "update"
-		});
-	}
-});
-async function exportPortablePrompts(packageSpec, opts) {
-	const { name: packageName } = parsePackageSpec(packageSpec);
-	const sections = opts.sections ?? DEFAULT_SECTIONS;
-	const spin = timedSpinner();
-	spin.start(`Resolving ${packageSpec}`);
-	const cwd = process.cwd();
-	const localVersion = (await readLocalDependencies(cwd).catch(() => [])).find((d) => d.name === packageName)?.version;
-	let resolved = (await resolvePackageDocsWithAttempts(packageName, {
-		version: localVersion,
-		cwd,
-		onProgress: (step) => spin.message(`${packageName}: ${RESOLVE_STEP_LABELS[step]}`)
-	})).package;
-	if (!resolved) {
-		spin.message(`Resolving local package: ${packageName}`);
-		resolved = await resolveLocalDep(packageName, cwd);
-	}
-	if (!resolved) {
-		spin.stop(`Could not find docs for: ${packageName}`);
+async function syncSinglePackage(packageSpec, config) {
+	if (isCrateSpec(packageSpec) && !packageSpec.slice(6).trim()) {
+		p.log.error("Invalid crate spec. Use format: crate:<name>");
 		return;
 	}
-	const version = localVersion || resolved.version || "latest";
-	const versionKey = getVersionKey(version);
-	const useCache = !opts.force && isCached(packageName, version);
-	if (!existsSync(join(cwd, "node_modules", packageName))) {
-		spin.message(`Downloading ${packageName}@${version} dist`);
-		await fetchPkgDist(packageName, version);
-	}
-	spin.stop(`Resolved ${packageName}@${useCache ? versionKey : version}`);
-	ensureCacheDir();
-	const skillDirName = computeSkillDirName(packageName);
-	const features = readConfig().features ?? defaultFeatures;
-	const agent = opts.agent === "none" ? null : opts.agent ?? await import("./detect2.mjs").then((m) => m.detectTargetAgent());
-	const baseDir = agent ? resolveBaseDir(cwd, agent, false) : join(cwd, ".claude", "skills");
-	const skillDir = opts.out ? resolve(cwd, opts.out) : join(baseDir, skillDirName);
-	if (existsSync(skillDir) && !opts.force) {
-		const existing = Object.values(SECTION_OUTPUT_FILES).filter((f) => existsSync(join(skillDir, f)));
-		if (existing.length > 0) p.log.warn(`Overwriting existing output files in ${relative(cwd, skillDir)}: ${existing.join(", ")}`);
-	}
-	mkdirSync(skillDir, { recursive: true });
-	const resSpin = timedSpinner();
-	resSpin.start("Fetching resources");
-	const resources = await fetchAndCacheResources({
-		packageName,
-		resolved,
-		version,
-		useCache,
-		features,
-		onProgress: (msg) => resSpin.message(msg)
-	});
-	resSpin.stop("Resources ready");
-	for (const w of resources.warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
-	linkAllReferences(skillDir, packageName, cwd, version, resources.docsType, void 0, features, resources.repoInfo);
-	const hasChangelog = detectChangelog(resolvePkgDir(packageName, cwd, version), getCacheDir(packageName, version));
-	const shippedDocs = hasShippedDocs(packageName, cwd, version);
-	const pkgFiles = getPkgKeyFiles(packageName, cwd, version);
-	const docFiles = listReferenceFiles(skillDir);
-	const prompts = buildAllSectionPrompts({
-		packageName,
-		skillDir,
-		version,
-		hasIssues: resources.hasIssues,
-		hasDiscussions: resources.hasDiscussions,
-		hasReleases: resources.hasReleases,
-		hasChangelog,
-		docFiles,
-		docsType: resources.docsType,
-		hasShippedDocs: shippedDocs,
-		pkgFiles,
-		features,
-		sections
-	});
-	ejectReferences(skillDir, packageName, cwd, version, resources.docsType, features, resources.repoInfo);
-	const skilldDir = join(skillDir, ".skilld");
-	if (existsSync(skilldDir)) rmSync(skilldDir, {
-		recursive: true,
-		force: true
-	});
-	for (const [section, prompt] of prompts) {
-		const portable = portabilizePrompt(prompt, section);
-		writeFileSync(join(skillDir, `PROMPT_${section}.md`), portable);
-	}
-	const relatedSkills = await findRelatedSkills(packageName, join(skillDir, ".."));
-	writeGeneratedSkillMd(skillDir, {
-		name: packageName,
-		version,
-		releasedAt: resolved.releasedAt,
-		description: resolved.description,
-		distTags: resolved.distTags,
-		relatedSkills,
-		hasIssues: resources.hasIssues,
-		hasDiscussions: resources.hasDiscussions,
-		hasReleases: resources.hasReleases,
-		hasChangelog,
-		docsType: resources.docsType,
-		hasShippedDocs: shippedDocs,
-		pkgFiles,
-		repoUrl: resolved.repoUrl,
-		features,
-		eject: true
-	});
-	writeLock(baseDir, skillDirName, {
-		packageName,
-		version,
-		repo: parseGitHubRepoSlug(resolved.repoUrl),
-		source: resources.docSource,
-		syncedAt: todayIsoDate(),
-		generator: "skilld"
-	});
-	if (agent) {
-		const shared = getSharedSkillsDir(cwd);
-		if (shared) linkSkillToAgents(skillDirName, shared, cwd, agent);
-		await ensureGitignore(shared ? SHARED_SKILLS_DIR : targets[agent].skillsDir, cwd, false);
-		await ensureAgentInstructions(agent, cwd, false);
-		registerProject(cwd);
-	} else await ensureGitignore(".claude/skills", cwd, false);
-	const relDir = relative(cwd, skillDir);
-	const sectionList = [...prompts.keys()];
-	p.log.success(`Skill installed to ${relDir}`);
-	const promptFiles = sectionList.map((s) => `PROMPT_${s}.md`).join(", ");
-	const outputFileList = sectionList.map((s) => SECTION_OUTPUT_FILES[s]).join(", ");
-	p.log.info(`Have your agent enhance the skill. Give it this prompt:\n\x1B[2m\x1B[3m  Read each prompt file (${promptFiles}) in ${relDir}/, read the\n  referenced files, then write your output to the matching file (${outputFileList}).\n  When done, run: skilld assemble\x1B[0m`);
+	return runSimpleSync(packageSpec, config);
 }
-export { syncCommand as a, isCrateSpec as i, ejectCommandDef as n, updateCommandDef as o, exportPortablePrompts as r, addCommandDef as t };
+export { createGithubResolver as i, bindClackUi as n, createSyncRun as r, syncCommand as t };
 
 //# sourceMappingURL=sync.mjs.map