skilld 1.7.4 → 2.0.0

package/dist/_chunks/sync.mjs

@@ -1,42 +1,22 @@
-import { d as getSharedSkillsDir, g as skillRefsSection, t as CACHE_DIR } from "./paths.mjs";
-import { A as getActiveFeatures, M as hasCompletedWizard, P as readConfig, h as listReferenceFiles, i as ensureCacheDir, t as createReferenceCache } from "./cache.mjs";
-import { r as getVersionKey } from "./version.mjs";
-import { n as sanitizeMarkdown } from "./sanitize.mjs";
-import { i as parseFrontmatter } from "./markdown.mjs";
-import { P as resolveGitHubRepo, a as toStoragePackageName, b as fetchGitSkills, dt as parsePackageSpec, i as resolveSkillName, l as fetchPkgDist, lt as parseGitHubRepoSlug, n as isCrateSpec, r as parseSkillInput, t as resolvePackageOrCrate, tt as isPrerelease, v as searchNpmPackages } from "./sources.mjs";
-import { a as targets } from "./detect.mjs";
 import { i as getModelLabel, n as detectImportedPackages } from "./agent.mjs";
-import { C as portabilizePrompt, E as SECTION_OUTPUT_FILES, _ as timedSpinner, i as computeSkillDirName, n as writeGeneratedSkillMd, o as linkSkillToAgents, r as writeSkillMd, s as sanitizeName, u as formatDuration, v as todayIsoDate, y as buildAllSectionPrompts } from "./prompts.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 parsePackageNames, c as readLock, d as writeLock, n as findSkillDirByPackage } from "./lockfile.mjs";
-import { t as semverDiff } from "./semver.mjs";
-import { t as getProjectState } from "./skills.mjs";
-import { t as runWizard } from "./wizard.mjs";
-import { a as ensureProjectFiles, c as linkShippedToAgents, i as ensureGitignore, l as resolveBaseDir, o as handleShippedSkills, s as installSkill } from "./skill-installer2.mjs";
-import { a as prepareSkillReferences, c as resolveAutoModel, d as applyCachedSections, h as writePromptFiles, i as findRelatedSkills, l as selectLlmConfig, m as writeBaseSkill, p as runSkillEnhancement, r as fetchAndCacheResources, s as DEFAULT_SECTIONS, t as buildSkillContext } from "./sync-pipeline.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 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 { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "pathe";
-import pLimit from "p-limit";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { styleText } from "node:util";
 import * as p from "@clack/prompts";
-import { defineCommand } from "citty";
-import { isCI } from "std-env";
+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 {}
-}
+import { createHooks } from "hookable";
 const npmResolver = async (spec, opts) => {
 	const resolution = await resolvePackageOrCrate(spec, {
 		cwd: opts.cwd,
@@ -92,20 +72,31 @@ function createGithubResolver(owner, repo) {
 	};
 }
 const RATE_LIMIT_RE = /\b429\b|rate.?limit|exhausted.*capacity|quota.*reset/i;
-async function runBaseSync(spec, config, ui, resolver, cwd, defaultSections) {
-	ui.resolveStart(spec);
+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) => ui.resolveProgress(msg)
+		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) ui.shippedInstalled(s.skillName, relative(cwd, s.skillDir));
+			for (const s of resolverResult.shipped) await hooks.callHook("shipped:installed", {
+				spec,
+				skillName: s.skillName,
+				skillDir: s.skillDir
+			});
 			return { kind: "shipped" };
 		}
-		ui.resolveFailed(resolverResult.identityName);
+		await hooks.callHook("resolve:failed", {
+			spec,
+			identityName: resolverResult.identityName,
+			attempts: resolverResult.attempts
+		});
 		return {
 			kind: "unresolved",
 			unresolved: resolverResult
@@ -116,24 +107,33 @@ async function runBaseSync(spec, config, ui, resolver, cwd, defaultSections) {
 	if (config.force) cache.clearForce();
 	const useCache = cache.has();
 	if (kind !== "crate" && !existsSync(join(cwd, "node_modules", identityName))) {
-		ui.downloadingDist();
+		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) ui.shippedInstalled(s.skillName, relative(cwd, s.skillDir));
+			for (const s of shipped.shipped) await hooks.callHook("shipped:installed", {
+				spec,
+				skillName: s.skillName,
+				skillDir: s.skillDir
+			});
 			return { kind: "shipped" };
 		}
 	}
-	ui.resolveDone(version, {
+	await hooks.callHook("resolve:done", {
+		spec,
+		version,
 		cached: useCache,
 		force: config.force
 	});
 	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)) ui.warn(`No local dependency found — using latest stable (${version}). Prerelease ${nextTag.version} available: skilld add ${identityName}@beta`);
+		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`
+		});
 	}
 	cache.ensure();
 	const isEject = !!config.eject;
@@ -171,7 +171,7 @@ async function runBaseSync(spec, config, ui, resolver, cwd, defaultSections) {
 		})()
 	} : void 0;
 	const features = getActiveFeatures(config.noSearch ? { search: false } : void 0);
-	ui.fetchStart();
+	await hooks.callHook("fetch:start", { spec });
 	const resources = await fetchAndCacheResources({
 		packageName: storageName,
 		resolved,
@@ -179,7 +179,10 @@ async function runBaseSync(spec, config, ui, resolver, cwd, defaultSections) {
 		useCache,
 		features,
 		from: config.from,
-		onProgress: (msg) => ui.fetchProgress(msg)
+		onProgress: (msg) => hooks.callHook("fetch:progress", {
+			spec,
+			message: msg
+		})
 	});
 	const parts = [];
 	if (resources.docsToIndex.length > 0) {
@@ -189,9 +192,16 @@ async function runBaseSync(spec, config, ui, resolver, cwd, defaultSections) {
 	if (resources.hasIssues) parts.push("issues");
 	if (resources.hasDiscussions) parts.push("discussions");
 	if (resources.hasReleases) parts.push("releases");
-	ui.fetchDone(parts, resources.usedCache);
-	for (const w of resources.warnings) ui.warn(w);
-	if (features.search) ui.indexStart();
+	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,
@@ -200,9 +210,12 @@ async function runBaseSync(spec, config, ui, resolver, cwd, defaultSections) {
 		resources,
 		features,
 		baseDir,
-		onIndexProgress: (msg) => ui.indexProgress(msg)
+		onIndexProgress: (msg) => hooks.callHook("index:progress", {
+			spec,
+			message: msg
+		})
 	});
-	if (features.search) ui.indexDone();
+	if (features.search) await hooks.callHook("index:done", { spec });
 	if (!isEject) {
 		const repoSlug = parseGitHubRepoSlug(resolved.repoUrl);
 		cache.linkPkgNamed(skillDir, cwd);
@@ -239,9 +252,13 @@ async function runBaseSync(spec, config, ui, resolver, cwd, defaultSections) {
 		features
 	});
 	ctx.overheadLines = writeBaseSkill(ctx, { eject: isEject }).split("\n").length;
-	ui.baseDone(relative(cwd, skillDir), config.mode === "update" ? "update" : "add");
+	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) ui.sectionsCached();
+	if (allSectionsCached) await hooks.callHook("sections:cached", { spec });
 	return {
 		kind: "ready",
 		state: {
@@ -259,8 +276,9 @@ async function runBaseSync(spec, config, ui, resolver, cwd, defaultSections) {
 		}
 	};
 }
-async function runEnhancePhase(state, llmConfig, config, ui, cwd) {
+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,
@@ -269,10 +287,10 @@ async function runEnhancePhase(state, llmConfig, config, ui, cwd) {
 		sections: llmConfig.sections,
 		customPrompt: llmConfig.customPrompt
 	});
-	else if (llmConfig) await enhanceWithUi(state.ctx, llmConfig, {
+	else if (llmConfig) await enhanceWithHooks(state.ctx, llmConfig, {
 		...config,
 		eject: isEject
-	}, ui);
+	}, hooks, spec);
 	if (isEject) {
 		const cache = createReferenceCache(state.storageName, state.version);
 		if (!config.debug) cache.clearSkillInternal(state.skillDir);
@@ -291,8 +309,11 @@ async function runEnhancePhase(state, llmConfig, config, ui, cwd) {
 		shared
 	});
 }
-async function enhanceWithUi(ctx, llmConfig, config, ui) {
-	ui.llmStart(getModelLabel(llmConfig.model));
+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,
@@ -300,276 +321,199 @@ async function enhanceWithUi(ctx, llmConfig, config, ui) {
 		sections: llmConfig.sections,
 		customPrompt: llmConfig.customPrompt,
 		eject: !!config.eject
-	}, (progress) => ui.llmProgress(progress));
-	if (result.wasOptimized) ui.llmDone({
+	}, (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 ui.llmFailed(result.error ?? "", { rateLimited: !!result.error && RATE_LIMIT_RE.test(result.error) });
+	else await hooks.callHook("enhance:failed", {
+		spec,
+		error: result.error ?? "",
+		rateLimited: !!result.error && RATE_LIMIT_RE.test(result.error)
+	});
 }
-function createClackUi({ cwd }) {
+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
+		};
+	}
+	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
+		};
+	}
+	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 = "";
-	return {
-		resolveStart(spec) {
-			currentSpec = spec;
-			spinner = timedSpinner();
-			spinner.start(`Resolving ${spec}`);
-		},
-		resolveProgress(msg) {
-			spinner?.message(msg);
-		},
-		resolveDone(version, opts) {
-			const suffix = opts.force ? " (force)" : opts.cached ? " (cached)" : "";
-			spinner?.stop(`Resolved ${currentSpec}@${version}${suffix}`);
-			spinner = null;
-		},
-		resolveFailed(identityName) {
-			spinner?.stop(`Could not find docs for: ${identityName}`);
-			spinner = null;
-		},
-		downloadingDist() {
-			spinner?.message("Downloading dist");
-		},
-		fetchStart() {
-			resourceSpinner = timedSpinner();
-			resourceSpinner.start("Finding resources");
-		},
-		fetchProgress(msg) {
-			resourceSpinner?.message(msg);
-		},
-		fetchDone(parts, cached) {
-			const summary = parts.length > 0 ? parts.join(", ") : "resources";
-			resourceSpinner?.stop(cached ? `Loaded ${summary} (cached)` : `Fetched ${summary}`);
-			resourceSpinner = null;
-		},
-		indexStart() {
-			indexSpinner = timedSpinner();
-			indexSpinner.start("Creating search index");
-		},
-		indexProgress(msg) {
-			indexSpinner?.message(msg);
-		},
-		indexDone() {
-			indexSpinner?.stop("Search index ready");
-			indexSpinner = null;
-		},
-		warn(msg) {
-			p.log.warn(`\x1B[33m${msg}\x1B[0m`);
-		},
-		baseDone(relPath, mode) {
-			p.log.success(mode === "update" ? `Updated skill: ${relPath}` : `Created base skill: ${relPath}`);
-		},
-		sectionsCached() {
-			p.log.success("Applied cached SKILL.md sections");
-		},
-		llmStart(modelLabel) {
-			p.log.step(modelLabel);
-			llmLog = p.taskLog({
-				title: `Agent exploring ${currentSpec}`,
-				limit: 3
-			});
-		},
-		llmProgress(progress) {
-			if (!llmLog) return;
-			const sectionPrefix = progress.section ? `[${progress.section}] ` : "";
-			const line = progress.chunk.startsWith("[") ? `${sectionPrefix}${progress.chunk}` : `${sectionPrefix}${progress.chunk}`;
-			llmLog.message(line);
-		},
-		llmDone(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(`\x1B[33mPartial failure: ${info.error}\x1B[0m`);
-			if (info.warnings) for (const w of info.warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
-		},
-		llmFailed(error, opts) {
-			if (!llmLog) return;
-			if (opts.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;
-		},
-		shippedInstalled(skillName, relPath) {
-			p.log.success(`Using published SKILL.md: ${skillName} → ${relPath}`);
-		}
-	};
-}
-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);
-		}
-		spin.stop(`No skills found in ${label}`);
-		return;
-	}
-	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;
-		}
-	} 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: []
-		});
-		if (p.isCancel(choices)) return;
-		const selectedNames = new Set(choices);
-		selected = skills.filter((s) => selectedNames.has(s.name));
-		if (selected.length === 0) return;
-	}
-	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 sourceType = source.type === "local" ? "local" : source.type;
-		installSkill({
-			cwd,
-			agent,
-			global: isGlobal,
-			baseDir,
-			skillDirName: skill.name,
-			lock: {
-				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"
-			},
-			skipLinkAgents: true
+	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
 		});
-	}
-	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
 	});
-	for (const skill of selected) {
-		const skillRel = relative(cwd, join(baseDir, skill.name));
-		const fileLines = ["SKILL.md", ...skill.files.map((f) => f.path)].map((f) => `  \x1B[90m└\x1B[0m ${f}`).join("\n");
-		p.log.success(`Installed \x1B[36m${skill.name}\x1B[0m \x1B[90m→ ${skillRel}\x1B[0m\n${fileLines}`);
-	}
-}
-async function syncGitHubRepo(opts) {
-	const { source, agent, global: isGlobal, yes } = opts;
-	const owner = source.owner;
-	const repo = source.repo;
-	const cwd = process.cwd();
-	const ui = createClackUi({ cwd });
-	const spec = `${owner}/${repo}`;
-	const result = await runBaseSync(spec, {
-		agent,
-		global: isGlobal,
-		force: opts.force,
-		from: opts.from
-	}, ui, createGithubResolver(owner, repo), cwd, DEFAULT_SECTIONS);
-	if (result.kind !== "ready") return;
-	const { state } = result;
-	const globalConfig = readConfig();
-	let llmConfig = null;
-	if (!state.allSectionsCached && !globalConfig.skipLlm && (!yes || opts.model)) llmConfig = await selectLlmConfig(opts.model);
-	await runEnhancePhase(state, llmConfig, {
-		agent,
-		global: isGlobal,
-		force: opts.force,
-		debug: opts.debug
-	}, ui, cwd);
-	await shutdownWorker();
-	track({
-		event: "install",
-		source: spec,
-		skills: state.skillDirName,
-		agents: agent,
-		...isGlobal && { global: "1" },
-		sourceType: "github-generated"
+	hooks.hook("enhance:progress", ({ progress }) => {
+		if (!llmLog) return;
+		const line = `${progress.section ? `[${progress.section}] ` : ""}${progress.chunk}`;
+		llmLog.message(line);
 	});
-	p.outro(`Synced ${spec} to ${relative(cwd, state.skillDir)}`);
-}
-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,
-		agent: config.agent,
-		global: config.global,
-		baseDir,
-		skillDirName,
-		lock: {
-			packageName: identityName,
-			version,
-			repo: repoSlug,
-			source: existingLock.source,
-			syncedAt: todayIsoDate(),
-			generator: "skilld"
-		},
-		skipLinkAgents: true
+	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));
 	});
-	const updatedLock = readLock(baseDir)?.skills[skillDirName];
-	const allPackages = parsePackageNames(updatedLock?.packages);
-	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: 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,
-		features
+	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)}`);
 	});
-	const sharedDir = !config.global && getSharedSkillsDir(cwd);
-	if (sharedDir) linkSkillToAgents(skillDirName, sharedDir, cwd, config.agent);
-	p.outro(`Merged ${identityName} into ${skillDirName}`);
 }
 const STATUS_ICONS = {
 	pending: "○",
@@ -583,37 +527,34 @@ 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"
 };
 function renderParallel(r) {
 	const maxNameLen = Math.max(...[...r.states.keys()].map((n) => n.length), 20);
 	const lines = [...r.states.values()].map((s) => {
-		const icon = STATUS_ICONS[s.status];
-		const color = STATUS_COLORS[s.status];
-		const reset = "\x1B[0m";
-		const dim = "\x1B[90m";
+		const icon = styleText(STATUS_COLORS[s.status], STATUS_ICONS[s.status]);
 		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 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}`;
 	});
 	const doneCount = [...r.states.values()].filter((s) => s.status === "done").length;
 	const errorCount = [...r.states.values()].filter((s) => s.status === "error").length;
-	logUpdate(`\x1B[1m${r.verb} ${r.total} packages\x1B[0m (${doneCount} done${errorCount > 0 ? `, ${errorCount} failed` : ""})\n` + lines.join("\n"));
+	logUpdate(`${styleText("bold", `${r.verb} ${r.total} packages`)} (${doneCount} done${errorCount > 0 ? `, ${errorCount} failed` : ""})\n` + lines.join("\n"));
 }
-function createParallelUi(name, render, version) {
-	const state = render.states.get(name);
-	if (!state) throw new Error(`createParallelUi: no state slot for "${name}"`);
-	function update(status, message, ver) {
+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;
@@ -622,58 +563,31 @@ function createParallelUi(name, render, version) {
 		if (ver) state.version = ver;
 		renderParallel(render);
 	}
-	if (version) state.version = version;
-	return {
-		resolveStart() {
-			update("resolving", "Resolving...");
-		},
-		resolveProgress(msg) {
-			update("resolving", msg);
-		},
-		resolveDone(ver, opts) {
-			update("downloading", opts.cached ? "Using cache" : opts.force ? "Re-fetching docs..." : "Fetching docs...", ver);
-		},
-		resolveFailed(_identityName) {},
-		downloadingDist() {
-			update("downloading", "Downloading dist...");
-		},
-		fetchStart() {},
-		fetchProgress(msg) {
-			update("downloading", msg);
-		},
-		fetchDone(_parts, _cached) {
-			update("downloading", "Linking references...");
-		},
-		indexStart() {
-			update("embedding", "Indexing docs");
-		},
-		indexProgress(msg) {
-			update("embedding", msg);
-		},
-		indexDone() {},
-		warn(_msg) {},
-		baseDone(_relPath, mode) {
-			update("done", mode === "update" ? "Skill updated" : "Base skill created");
-		},
-		sectionsCached() {},
-		llmStart(modelLabel) {
-			update("generating", modelLabel);
-		},
-		llmProgress(progress) {
-			const status = progress.type === "reasoning" ? "exploring" : "generating";
-			const sectionPrefix = progress.section ? `[${progress.section}] ` : "";
-			update(status, progress.chunk.startsWith("[") ? `${sectionPrefix}${progress.chunk}` : `${sectionPrefix}${progress.chunk}`);
-		},
-		llmDone(_info) {
-			update("done", "Skill optimized");
-		},
-		llmFailed(error, _opts) {
-			update("error", error);
-		},
-		shippedInstalled(_skillName, _relPath) {
-			update("done", "Published SKILL.md");
-		}
-	};
+	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,
@@ -688,11 +602,16 @@ async function syncPackagesParallel(config) {
 	const { packages, concurrency = 5 } = config;
 	const cwd = process.cwd();
 	const states = /* @__PURE__ */ new Map();
-	for (const spec of packages) states.set(spec, {
-		name: spec,
-		status: "pending",
-		message: "Waiting..."
-	});
+	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",
@@ -700,17 +619,19 @@ async function syncPackagesParallel(config) {
 	};
 	ensureCacheDir();
 	renderParallel(render);
-	const limit = pLimit(concurrency);
-	const baseConfig = {
+	const run = createSyncRun({
+		cwd,
+		resolver: npmResolver,
 		agent: config.agent,
 		global: config.global,
 		mode: config.mode,
-		force: config.force
-	};
-	const baseResults = await Promise.allSettled(packages.map((spec) => limit(async () => {
-		const { name } = parsePackageSpec(spec);
-		return runBaseSync(spec, baseConfig, createParallelUi(name, render), npmResolver, cwd, DEFAULT_SECTIONS);
-	})));
+		force: config.force,
+		debug: config.debug,
+		defaultSections: DEFAULT_SECTIONS
+	});
+	bindParallelUi(run.hooks, render);
+	const limit = pLimit(concurrency);
+	const baseResults = await Promise.allSettled(packages.map((spec) => limit(() => run.runBase(spec))));
 	logUpdate.done();
 	const ready = [];
 	const shippedCount = [];
@@ -736,13 +657,13 @@ async function syncPackagesParallel(config) {
 			continue;
 		}
 		if (result.kind === "unresolved") {
-			const npmAttempt = result.unresolved.attempts.find((a) => a.source === "npm");
+			const npmAttempt = result.attempts.find((a) => a.source === "npm");
 			let reason;
 			if (npmAttempt?.status === "not-found") {
-				const suggestions = await searchNpmPackages(result.unresolved.identityName, 3);
+				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.unresolved.attempts.filter((a) => a.status !== "success").map((a) => a.message || a.source).join("; ") || "No docs found";
+			} 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";
@@ -754,14 +675,14 @@ async function syncPackagesParallel(config) {
 			});
 			continue;
 		}
-		if (result.kind === "merge-needed") {
+		if (result.kind === "error") {
 			errors.push({
 				spec,
-				reason: `Skill dir already holds ${result.state.existingLock.packageName} — run sequentially to merge`
+				reason: result.reason
 			});
 			continue;
 		}
-		ready.push({
+		if (result.kind === "ready") ready.push({
 			spec,
 			state: result.state
 		});
@@ -770,7 +691,7 @@ async function syncPackagesParallel(config) {
 	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(`\x1B[33m${w}\x1B[0m`);
+	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 = [];
@@ -790,46 +711,25 @@ async function syncPackagesParallel(config) {
 				}
 			}
 			renderParallel(render);
-			for (const r of uncached) {
-				const ui = createParallelUi(r.spec, render, getVersionKey(r.state.version));
-				await runEnhancePhase(r.state, llmConfig, {
-					agent: config.agent,
-					global: config.global,
-					force: config.force,
-					debug: config.debug
-				}, ui, cwd);
-			}
+			for (const r of uncached) await run.runEnhance(r.state, llmConfig);
 		} else if (llmConfig) {
 			p.log.step(getModelLabel(llmConfig.model));
-			for (const r of uncached) states.set(r.spec, {
-				name: r.spec,
-				status: "pending",
-				message: "Waiting...",
-				version: getVersionKey(r.state.version)
-			});
+			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(async () => {
-				const ui = createParallelUi(r.spec, render, getVersionKey(r.state.version));
-				await runEnhancePhase(r.state, llmConfig, {
-					agent: config.agent,
-					global: config.global,
-					force: config.force,
-					debug: config.debug
-				}, ui, cwd);
-			})));
+			const llmResults = await Promise.allSettled(uncached.map((r) => limit(() => run.runEnhance(r.state, llmConfig))));
 			logUpdate.done();
 			const llmSucceeded = llmResults.filter((x) => x.status === "fulfilled").length;
 			p.log.success(`Enhanced ${llmSucceeded}/${uncached.length} skills with LLM`);
 		}
-	} else for (const r of ready) {
-		const ui = createParallelUi(r.spec, render, getVersionKey(r.state.version));
-		await runEnhancePhase(r.state, null, {
-			agent: config.agent,
-			global: config.global,
-			force: config.force,
-			debug: config.debug
-		}, ui, cwd);
-	}
+	} else for (const r of ready) await run.runEnhance(r.state, null);
 	await ensureProjectFiles({
 		cwd,
 		agent: config.agent,
@@ -837,7 +737,7 @@ async function syncPackagesParallel(config) {
 	});
 	await shutdownWorker();
 	p.outro(`${pastVerb} ${ready.length}/${packages.length} packages`);
-	const { suggestPrepareHook } = await import("./cli-helpers2.mjs");
+	const { suggestPrepareHook } = await import("./prepare-hook.mjs");
 	try {
 		await suggestPrepareHook(cwd);
 	} catch (err) {
@@ -866,6 +766,52 @@ function aggregateUpdateCtx(ready) {
 		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,
+		agent: config.agent,
+		global: config.global,
+		baseDir,
+		skillDirName,
+		lock: {
+			packageName: identityName,
+			version,
+			repo: repoSlug,
+			source: existingLock.source,
+			syncedAt: todayIsoDate(),
+			generator: "skilld"
+		},
+		skipLinkAgents: true
+	});
+	const updatedLock = readLock(baseDir)?.skills[skillDirName];
+	const allPackages = parsePackageNames(updatedLock?.packages);
+	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: 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,
+		features
+	});
+	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",
 	"github-docs": "GitHub versioned docs",
@@ -878,11 +824,11 @@ 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}`);
 	}
 }
@@ -979,9 +925,10 @@ async function pickFromList(packages, state) {
 }
 async function runSimpleSync(packageSpec, config) {
 	const cwd = process.cwd();
-	const ui = createClackUi({ cwd });
 	const isEject = !!config.eject;
-	const result = await runBaseSync(packageSpec, {
+	const run = createSyncRun({
+		cwd,
+		resolver: npmResolver,
 		agent: config.agent,
 		global: config.global,
 		mode: config.mode,
@@ -989,18 +936,25 @@ async function runSimpleSync(packageSpec, config) {
 		noSearch: config.noSearch,
 		name: config.name,
 		from: config.from,
-		eject: config.eject
-	}, ui, npmResolver, cwd, DEFAULT_SECTIONS);
-	if (result.kind === "shipped") {
+		debug: config.debug,
+		eject: config.eject,
+		defaultSections: DEFAULT_SECTIONS,
+		onMergeNeeded: (state) => handleMerge(state, {
+			agent: config.agent,
+			global: config.global
+		}, cwd)
+	});
+	bindClackUi(run.hooks, { cwd });
+	const base = await run.runBase(packageSpec);
+	if (base.kind === "shipped") {
 		p.outro(`Synced ${packageSpec}`);
 		return;
 	}
-	if (result.kind === "unresolved") {
-		const { unresolved } = result;
+	if (base.kind === "unresolved") {
 		if (!isCrateSpec(packageSpec)) {
-			const suggestions = await searchNpmPackages(unresolved.identityName);
+			const suggestions = await searchNpmPackages(base.identityName);
 			if (suggestions.length > 0) {
-				showResolveAttempts(unresolved.attempts);
+				showResolveAttempts(base.attempts);
 				const selected = await p.select({
 					message: "Did you mean one of these?",
 					options: [...suggestions.map((s) => ({
@@ -1016,28 +970,16 @@ async function runSimpleSync(packageSpec, config) {
 				return;
 			}
 		}
-		showResolveAttempts(unresolved.attempts);
+		showResolveAttempts(base.attempts);
 		return;
 	}
-	if (result.kind === "merge-needed") {
-		await handleMerge(result.state, {
-			agent: config.agent,
-			global: config.global
-		}, cwd);
-		return;
-	}
-	const { state } = result;
+	if (base.kind === "merged" || base.kind === "error") return;
+	const { state } = base;
 	const globalConfig = readConfig();
 	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 runEnhancePhase(state, llmConfig, {
-		agent: config.agent,
-		global: config.global,
-		force: config.force,
-		debug: config.debug,
-		eject: config.eject
-	}, ui, cwd);
+	await run.runEnhance(state, llmConfig);
 	await shutdownWorker();
 	const ejectMsg = isEject ? " (ejected)" : "";
 	const relDir = relative(cwd, state.skillDir);
@@ -1055,447 +997,6 @@ async function syncSinglePackage(packageSpec, config) {
 	}
 	return runSimpleSync(packageSpec, config);
 }
-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 sections = opts.sections ?? DEFAULT_SECTIONS;
-	const spin = timedSpinner();
-	spin.start(`Resolving ${packageSpec}`);
-	const cwd = process.cwd();
-	const { packageName, localVersion, resolved } = await resolvePackageOrCrate(packageSpec, {
-		cwd,
-		onProgress: (label) => spin.message(`${packageSpec}: ${label}`)
-	});
-	if (!resolved) {
-		spin.stop(`Could not find docs for: ${packageSpec}`);
-		return;
-	}
-	const version = localVersion || resolved.version || "latest";
-	const cache = createReferenceCache(packageName, version);
-	const useCache = !opts.force && cache.has();
-	if (!existsSync(join(cwd, "node_modules", packageName))) {
-		spin.message(`Downloading ${packageName}@${version} dist`);
-		await fetchPkgDist(packageName, version);
-	}
-	spin.stop(`Resolved ${packageName}@${useCache ? cache.versionKey : version}`);
-	cache.ensure();
-	const skillDirName = computeSkillDirName(packageName);
-	const features = getActiveFeatures();
-	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`);
-	const { hasChangelog, shippedDocs, pkgFiles, relatedSkills } = await prepareSkillReferences({
-		packageName,
-		version,
-		cwd,
-		skillDir,
-		resources,
-		features,
-		baseDir: join(skillDir, "..")
-	});
-	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
-	});
-	cache.eject(skillDir, cwd, resources.docsType, {
-		features,
-		repoInfo: resources.repoInfo
-	});
-	cache.clearSkillInternal(skillDir);
-	for (const [section, prompt] of prompts) {
-		const portable = portabilizePrompt(prompt, section);
-		writeFileSync(join(skillDir, `PROMPT_${section}.md`), portable);
-	}
-	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
-	});
-	const repoSlug = parseGitHubRepoSlug(resolved.repoUrl);
-	if (agent) {
-		const { shared } = installSkill({
-			cwd,
-			agent,
-			global: false,
-			baseDir,
-			skillDirName,
-			lock: {
-				packageName,
-				version,
-				repo: repoSlug,
-				source: resources.docSource,
-				syncedAt: todayIsoDate(),
-				generator: "skilld"
-			}
-		});
-		await ensureProjectFiles({
-			cwd,
-			agent,
-			global: false,
-			shared
-		});
-	} else {
-		writeLock(baseDir, skillDirName, {
-			packageName,
-			version,
-			repo: repoSlug,
-			source: resources.docSource,
-			syncedAt: todayIsoDate(),
-			generator: "skilld"
-		});
-		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`);
-}
-export { updateCommandDef as a, syncCommand as i, ejectCommandDef as n, exportPortablePrompts as r, addCommandDef as t };
+export { createGithubResolver as i, bindClackUi as n, createSyncRun as r, syncCommand as t };
 
 //# sourceMappingURL=sync.mjs.map