magus-cli 7.12.2 → 7.14.0

package/src/services/market-ops-skill.ts

@@ -0,0 +1,788 @@
+/**
+ * market-ops-skill.ts — plans for `skill add`, `skill edit` and
+ * `skill remove`.
+ *
+ * Read-only planners. Each plan syncs magus's working clone in its apply and
+ * is planned again there before its first write.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { checkIgnore } from "./git-write.js";
+import { ORIGIN_FILE, forgetBasesFor, recordBase } from "./market-bases.js";
+import {
+	type ChangeSpec,
+	changeSteps,
+	cloneOf,
+	deliveryTarget,
+	linkRefusal,
+	targetLine,
+	writeJson,
+} from "./market-change.js";
+import { type Snapshot, cloneUrl } from "./market-clone.js";
+import {
+	copyFileUnder,
+	linkUnder,
+	refuseLinkUnder,
+	removeUnder,
+} from "./market-fs.js";
+import {
+	SYMLINK_MODE,
+	type SkillFile,
+	addPluginEntry,
+	currentVersion,
+	findSkillOwners,
+	inDomain,
+	joinRel,
+	nextVersion,
+	pluginEntries,
+	pluginRelDir,
+	pluginRootOf,
+	removePluginEntry,
+	setEntryVersion,
+	treeHash,
+	validPackageName,
+	validSkillName,
+} from "./market-layout.js";
+import {
+	type MarketCommand,
+	computePlanId,
+	freshSnapshot,
+	manifestAt,
+	planError,
+	resolvePluginRef,
+} from "./market-ops.js";
+import {
+	type InstalledAt,
+	installReaches,
+	installedScopes,
+	moveInstalls,
+	offHereReason,
+	profileManaged,
+	readSourceSets,
+	removeLocalCopy,
+	settleLocalCopy,
+} from "./market-publish.js";
+import {
+	type TrustedRegistration,
+	listCompanyMarketplaces,
+} from "./market-registry.js";
+import {
+	type FileChange,
+	type LocalCopy,
+	MarketError,
+	type MarketPlan,
+	type MarketStep,
+	type PlanAnswer,
+	staleError,
+} from "./market-types.js";
+import { fastForwardCloneIfPresent } from "./marketplace-refresh.js";
+import { getUserSkillsDir } from "./skills-manager.js";
+
+import {
+	MANIFEST,
+	type PluginView,
+	SCOPE_WORD,
+	bumpFrom,
+	bumpStep,
+	filesUnder,
+	installLines,
+	installStep,
+	pluginViewAt,
+	readPlugin,
+	versionFiles,
+	versionLine,
+} from "./market-ops-content.js";
+import {
+	NEW_PLUGIN_VERSION,
+	newPluginLayout,
+	refreshStep,
+	writeNewPlugin,
+} from "./market-ops-plugin.js";
+
+// ─── skill add ───────────────────────────────────────────────────────────────
+
+export interface SkillAddArgs {
+	skill: string;
+	plugin: string;
+	from: "project" | "global";
+	keepLocal: boolean;
+	/**
+	 * Create the plugin, in the same commit, when the marketplace has none of
+	 * that name. Without it a missing plugin is `not-found`.
+	 */
+	createPlugin?: boolean;
+	/** The new plugin's description; read only when it is created. */
+	description?: string;
+}
+
+export function skillFolder(
+	cwd: string,
+	where: "project" | "global",
+	skill: string,
+) {
+	return where === "global"
+		? path.join(getUserSkillsDir(), skill)
+		: path.join(cwd, ".claude", "skills", skill);
+}
+
+/**
+ * Refuse a skill folder destination reached through a link: a linked
+ * `.claude/skills` (or a linked skill folder) would put the copy somewhere
+ * other than the project or USER skills it names. The project folder, and
+ * the Claude config folder for USER skills, are trusted; every existing part
+ * below them is checked.
+ */
+export function refuseLinkedSkillFolder(
+	cwd: string,
+	where: "project" | "global",
+	skill: string,
+): void {
+	const root = where === "global" ? path.dirname(getUserSkillsDir()) : cwd;
+	const rel =
+		where === "global"
+			? `${path.basename(getUserSkillsDir())}/${skill}`
+			: `.claude/skills/${skill}`;
+	const link = linkUnder(root, rel);
+	if (link === null) return;
+	const reached =
+		where === "global"
+			? "Your USER skills are reached through a link"
+			: `This project's skills are reached through a link at ${link}`;
+	throw new MarketError(
+		"other",
+		`${reached}, so magus will not copy ${skill} there — nothing was changed`,
+		"replace the link with a real folder, then run the command again",
+	);
+}
+
+export function checkSkillName(skill: string): void {
+	if (!validSkillName(skill)) {
+		throw new MarketError(
+			"invalid-name",
+			`${skill} is not a skill folder name (letters, digits, dots, dashes, underscores)`,
+		);
+	}
+}
+
+export const PROFILE_KEEPS =
+	"this project's profile installs this skill folder; remove the skill from the profile in magus to use the plugin's version";
+
+export async function planSkillAdd(
+	args: SkillAddArgs,
+	cwd: string,
+): Promise<PlanAnswer> {
+	const command: MarketCommand = "market skill add";
+	try {
+		checkSkillName(args.skill);
+		const folder = skillFolder(cwd, args.from, args.skill);
+		const where = args.from === "global" ? "your USER skills" : "this project";
+		if (!fs.existsSync(path.join(folder, "SKILL.md"))) {
+			throw new MarketError(
+				"not-found",
+				`${where} has no skill named ${args.skill}`,
+			);
+		}
+		const ref = await resolvePluginRef(args.plugin);
+		const snapNow = await freshSnapshot(ref.m);
+		const manifestNow = await manifestAt(snapNow, ref.m.name);
+		const exists = pluginEntries(manifestNow).some(
+			(p) => p.name === ref.plugin,
+		);
+		if (!exists && !args.createPlugin) {
+			throw new MarketError(
+				"not-found",
+				`${ref.m.name} has no plugin named ${ref.plugin}`,
+				"`magus market list` shows its plugins; add --create-plugin to create it with this skill",
+			);
+		}
+		// A plugin created here starts at its first version: nothing to bump.
+		const layout = exists
+			? null
+			: newPluginLayout(ref.m, snapNow, manifestNow, ref.plugin);
+		const view: PluginView = layout
+			? {
+					m: ref.m,
+					snap: snapNow,
+					manifest: manifestNow,
+					plugin: ref.plugin,
+					dir: layout.dir,
+					pluginJsonPath: layout.pluginJsonPath,
+					pluginJson: null,
+				}
+			: await pluginViewAt(ref.m, snapNow, manifestNow, ref.plugin);
+		const { m, snap, plugin, dir } = view;
+		const skillDir = joinRel(dir, "skills", args.skill);
+		if (filesUnder(snap, skillDir).length > 0) {
+			throw new MarketError(
+				"name-taken",
+				`${plugin} already has a skill named ${args.skill}`,
+				"to send your edits to it, use `magus market publish`",
+			);
+		}
+		const { from, to } = layout
+			? { from: null, to: NEW_PLUGIN_VERSION }
+			: bumpFrom(view);
+		const sets = await readSourceSets(folder, snap.dir, skillDir);
+		if (sets.published.length === 0) {
+			throw new MarketError(
+				"other",
+				`Nothing in ${args.skill} can be published (every file is excluded)`,
+			);
+		}
+		const target = await deliveryTarget(m.source, m.name);
+		const pluginId = `${plugin}@${m.name}`;
+		const installs = await installedScopes(pluginId, cwd);
+		const copyScope = args.from === "global" ? "user" : "project";
+		const managed =
+			args.from === "project" && (await profileManaged(cwd, args.skill));
+		const keepReason = args.keepLocal
+			? "--keep-local"
+			: managed
+				? PROFILE_KEEPS
+				: !installReaches(
+							copyScope,
+							installs.map((i) => i.scope),
+						)
+					? `${plugin} is not installed where this copy loads`
+					: sets.notPublished.length > 0
+						? `holds files that will not be published: ${sets.notPublished.map((n) => n.path).join(", ")}`
+						: await offHereReason(plugin, pluginId, cwd);
+		const predicted: LocalCopy = keepReason
+			? {
+					scope: copyScope,
+					name: args.skill,
+					action: "kept",
+					reason: keepReason,
+				}
+			: { scope: copyScope, name: args.skill, action: "removed" };
+		const created = layout
+			? [
+					{ path: MANIFEST, change: "modified" as const },
+					{ path: layout.pluginJsonPath, change: "added" as const },
+				]
+			: versionFiles(view);
+		const files = [
+			...sets.published.map((f) => ({
+				path: joinRel(skillDir, f.path),
+				change: "added" as const,
+			})),
+			...created,
+		];
+		const state: ChangeSpec["state"] & { moved?: boolean } = {};
+		const steps: MarketStep[] = [
+			...(layout
+				? [
+						{
+							id: "edit",
+							label: `wrote ${plugin}`,
+							outside: false,
+							async run(ctx: Parameters<MarketStep["run"]>[0]) {
+								writeNewPlugin(
+									cloneOf(ctx),
+									m,
+									view.manifest,
+									layout,
+									args.description,
+								);
+								return undefined;
+							},
+						} satisfies MarketStep,
+					]
+				: []),
+			{
+				id: "copy",
+				label: `copied ${args.skill} into ${plugin}`,
+				outside: false,
+				async run(ctx) {
+					const clone = cloneOf(ctx);
+					// A link committed at `plugins/<p>/skills`, or at the new
+					// skill's folder, would carry the copy outside the clone:
+					// every target is checked before the first write.
+					const linked = linkRefusal(m.name);
+					for (const f of sets.published) {
+						refuseLinkUnder(clone, joinRel(skillDir, f.path), linked);
+					}
+					for (const f of sets.published) {
+						copyFileUnder(
+							clone,
+							joinRel(skillDir, f.path),
+							path.join(folder, f.path),
+							linked,
+						);
+					}
+					return undefined;
+				},
+			},
+			...(layout ? [] : [bumpStep(view, to)]),
+			...changeSteps({
+				label: m.name,
+				source: m.source,
+				branch: snap.branch,
+				target,
+				stage: layout
+					? [MANIFEST, dir]
+					: [skillDir, ...versionFiles(view).map((f) => f.path)],
+				files,
+				message: layout
+					? `${plugin}: create plugin with ${args.skill} skill (${to})`
+					: `${plugin}: add ${args.skill} skill (${to})`,
+				slug: `${plugin}-${to}`,
+				prBody: layout
+					? `Creates the plugin \`${plugin}\` (${to}) in ${m.name} with the skill \`${args.skill}\`.`
+					: `Adds the skill \`${args.skill}\` to \`${plugin}\` and bumps it to ${to}.`,
+				verify: [{ dir: skillDir, files: sets.published }],
+				state,
+			}),
+			...(layout ? [refreshStep(m.name, state)] : []),
+			installStep(view, installs, to, state),
+			{
+				id: "local-copy",
+				label: "settled the local copy",
+				outside: true,
+				async run() {
+					const copy = await settleLocalCopy({
+						folder,
+						committed: sets.published,
+						copy: { scope: copyScope, name: args.skill },
+						keepReason,
+						moved: state.moved === true,
+						plugin,
+						pluginId,
+						cwd,
+					});
+					if (
+						copy.action === "kept" &&
+						!copy.partial &&
+						!managed &&
+						state.commit
+					) {
+						recordBase(folder, {
+							marketplace: m.name,
+							repo: m.source,
+							plugin,
+							skill: args.skill,
+							commit: state.commit,
+							tree: sets.hash,
+						});
+					}
+					return { patch: { localCopy: copy } };
+				},
+			},
+		];
+		const lines = [
+			...(layout
+				? [
+						`Creates the plugin ${plugin} (${to}) in ${m.name}, with the skill ${args.skill} from ${where}, in one commit`,
+					]
+				: [
+						`Adds the skill ${args.skill} from ${where} to ${pluginId}`,
+						versionLine(plugin, from, to),
+					]),
+			`Publishes ${sets.published.length} file${sets.published.length === 1 ? "" : "s"}: ${sets.published.map((f) => f.path).join(", ")}`,
+			...(sets.untrackedFolder
+				? [
+						"This folder is not tracked in the project's git; every file is listed",
+					]
+				: []),
+			...(sets.notPublished.length > 0
+				? [
+						`Not published: ${sets.notPublished.map((n) => `${n.path} (${n.reason})`).join(", ")}`,
+					]
+				: []),
+			targetLine(target, snap.branch),
+			...installLines(plugin, installs, to),
+			predicted.action === "removed"
+				? `Afterwards removes ${args.from === "global" ? "your USER" : "this project's"} copy of ${args.skill}`
+				: `Keeps ${args.from === "global" ? "your USER" : "this project's"} copy of ${args.skill}: ${predicted.reason}`,
+		];
+		const plan: MarketPlan = {
+			command,
+			lines,
+			planId: computePlanId({
+				op: "skill-add",
+				skill: args.skill,
+				from: args.from,
+				keepLocal: args.keepLocal,
+				plugin: pluginId,
+				createPlugin: layout ? { description: args.description ?? null } : null,
+				commit: snap.commit,
+				hash: sets.hash,
+				notPublished: sets.notPublished,
+				target,
+				version: { from, to },
+				installs,
+				localCopy: predicted,
+			}),
+			summary: {
+				marketplace: m.name,
+				plugin,
+				skill: args.skill,
+				version: { from, to },
+				files,
+				notPublished: sets.notPublished,
+				target,
+			},
+			steps,
+			sync: { name: m.name, url: cloneUrl(m.source) },
+			lock: m.name,
+			replan: () => planSkillAdd({ ...args, plugin: pluginId }, cwd),
+			doneMessage: `${args.skill} is in ${pluginId} ${to}. Takes effect in new sessions, or after /reload-plugins.`,
+		};
+		return { kind: "plan", plan };
+	} catch (error) {
+		return planError(command, error);
+	}
+}
+
+// ─── skill edit ──────────────────────────────────────────────────────────────
+
+export interface SkillEditArgs {
+	skill: string;
+	plugin?: string;
+	to: "project" | "global";
+}
+
+/** The one plugin holding `skill`, read from fresh state. */
+export async function ownerOf(
+	skill: string,
+	ref: string | undefined,
+): Promise<PluginView> {
+	if (ref) {
+		const view = await readPlugin(ref);
+		if (
+			!view.snap.entries.has(joinRel(view.dir, "skills", skill, "SKILL.md"))
+		) {
+			throw new MarketError(
+				"not-found",
+				`${view.plugin}@${view.m.name} has no skill named ${skill}`,
+			);
+		}
+		return view;
+	}
+	const all = await listCompanyMarketplaces();
+	const reads = await Promise.all(
+		all.map(async (m) => {
+			try {
+				const snap = await freshSnapshot(m);
+				return { m, snap, manifest: await manifestAt(snap, m.name) };
+			} catch (error) {
+				return { m, error };
+			}
+		}),
+	);
+	const failed = reads.filter((r) => "error" in r);
+	if (failed.length > 0) {
+		throw staleError(
+			failed.map((r) => r.m.name),
+			`Could not read the current state of ${failed.map((r) => r.m.name).join(", ")}`,
+			"run `magus market fetch`, or name the target with --plugin <plugin@marketplace>",
+		);
+	}
+	const ok = reads.filter(
+		(
+			r,
+		): r is {
+			m: TrustedRegistration;
+			snap: Snapshot;
+			manifest: Record<string, unknown>;
+		} => !("error" in r),
+	);
+	const owners = findSkillOwners(
+		ok.map((r) => ({
+			marketplace: r.m.name,
+			plugins: pluginEntries(r.manifest).map((p) => ({
+				name: p.name,
+				dir: pluginRelDir(p.source, pluginRootOf(r.manifest)),
+			})),
+			paths: new Set(r.snap.entries.keys()),
+		})),
+		skill,
+	);
+	if (owners.length === 0) {
+		throw new MarketError(
+			"not-found",
+			`No company plugin holds a skill named ${skill}`,
+			"`magus market list` shows each plugin's skills",
+		);
+	}
+	if (owners.length > 1) {
+		throw new MarketError(
+			"ambiguous",
+			`More than one company plugin holds ${skill}: ${owners.join(", ")}`,
+			"name one with --plugin <plugin@marketplace>",
+		);
+	}
+	return readPlugin(owners[0] as string);
+}
+
+export async function planSkillEdit(
+	args: SkillEditArgs,
+	cwd: string,
+): Promise<PlanAnswer> {
+	const command: MarketCommand = "market skill edit";
+	try {
+		checkSkillName(args.skill);
+		const folder = skillFolder(cwd, args.to, args.skill);
+		refuseLinkedSkillFolder(cwd, args.to, args.skill);
+		if (fs.existsSync(folder)) {
+			throw new MarketError(
+				"name-taken",
+				args.to === "global"
+					? `Your USER skills already have their own ${args.skill} skill`
+					: `This project already has its own ${args.skill} skill`,
+				"publish it, or delete it first",
+			);
+		}
+		const view = await ownerOf(args.skill, args.plugin);
+		const { m, snap, plugin, dir } = view;
+		const skillDir = joinRel(dir, "skills", args.skill);
+		const files = filesUnder(snap, skillDir);
+		// The provenance file is magus's own: never taken from a repository.
+		const copied = files.filter((f) => f.path !== ORIGIN_FILE);
+		const entry = pluginEntries(view.manifest).find((p) => p.name === plugin);
+		const version = currentVersion(view.pluginJson, entry) ?? "unversioned";
+		const where = args.to === "global" ? "your USER skills" : "this project";
+		const loads =
+			args.to === "global"
+				? "every project loads your copy instead of the plugin's until you publish it"
+				: "this project loads your copy instead of the plugin's until you publish it";
+		const steps: MarketStep[] = [
+			{
+				id: "copy",
+				label: `copied ${args.skill} into ${where}`,
+				outside: true,
+				async run(ctx) {
+					const clone = cloneOf(ctx);
+					const src = path.join(clone, skillDir);
+					// Neither side may be reached through a link: a committed link
+					// above a file would read from, or write to, outside both.
+					const linked = (link: string) =>
+						new MarketError(
+							"other",
+							`${plugin} holds a link at ${link}, so ${args.skill} cannot be copied safely — nothing was changed`,
+							"replace the link with a folder in the marketplace repository, then run the command again",
+						);
+					for (const f of copied) {
+						const parent = path.posix.dirname(f.path);
+						refuseLinkUnder(
+							clone,
+							joinRel(skillDir, f.mode === SYMLINK_MODE ? parent : f.path),
+							linked,
+						);
+					}
+					refuseLinkedSkillFolder(cwd, args.to, args.skill);
+					fs.mkdirSync(folder, { recursive: true });
+					for (const f of copied) {
+						const from = path.join(src, f.path);
+						const out = path.join(folder, f.path);
+						refuseLinkUnder(folder, path.posix.dirname(f.path), linked);
+						fs.mkdirSync(path.dirname(out), { recursive: true });
+						if (f.mode === SYMLINK_MODE) {
+							fs.symlinkSync(fs.readlinkSync(from), out);
+						} else {
+							fs.copyFileSync(from, out, fs.constants.COPYFILE_EXCL);
+							if (f.mode === "100755") fs.chmodSync(out, 0o755);
+						}
+					}
+					return undefined;
+				},
+			},
+			{
+				id: "base",
+				label: "recorded where the copy came from",
+				outside: true,
+				async run(ctx) {
+					const here = await checkIgnore(
+						folder,
+						files.map((f) => f.path),
+					);
+					const there = await checkIgnore(
+						cloneOf(ctx),
+						files.map((f) => joinRel(skillDir, f.path)),
+					);
+					const ignoredHere = here.ok ? here.value : new Set<string>();
+					const ignoredThere = new Set(
+						[...(there.ok ? there.value : [])].map((p) =>
+							p.slice(skillDir.length + 1),
+						),
+					);
+					const domain = files.filter((f) =>
+						inDomain(f.path, f.mode, ignoredHere, ignoredThere),
+					);
+					recordBase(folder, {
+						marketplace: m.name,
+						repo: m.source,
+						plugin,
+						skill: args.skill,
+						commit: snap.commit,
+						tree: treeHash(domain),
+					});
+					return {
+						patch: {
+							localCopy: {
+								scope: args.to === "global" ? "user" : "project",
+								name: args.skill,
+								action: "created",
+							},
+						},
+					};
+				},
+			},
+		];
+		const plan: MarketPlan = {
+			command,
+			lines: [
+				`Copies ${args.skill} from ${plugin} ${version} (GitHub) into ${where}; ${loads}`,
+				`${copied.length} file${copied.length === 1 ? "" : "s"}: ${copied.map((f) => f.path).join(", ")}`,
+				"Changes no repository",
+			],
+			planId: computePlanId({
+				op: "skill-edit",
+				skill: args.skill,
+				owner: `${plugin}@${m.name}`,
+				commit: snap.commit,
+				to: args.to,
+				files: files.map((f) => [f.path, f.oid, f.mode]),
+			}),
+			summary: { marketplace: m.name, plugin, skill: args.skill },
+			steps,
+			sync: { name: m.name, url: cloneUrl(m.source) },
+			lock: m.name,
+			replan: () =>
+				planSkillEdit({ ...args, plugin: `${plugin}@${m.name}` }, cwd),
+			doneMessage: `${where === "this project" ? "This project" : "Your USER skills"} now hold${where === "this project" ? "s" : ""} a copy of ${args.skill} to edit. Publish it with \`magus market publish ${args.skill}\`.`,
+		};
+		return { kind: "plan", plan };
+	} catch (error) {
+		return planError(command, error);
+	}
+}
+
+// ─── skill remove ────────────────────────────────────────────────────────────
+
+export interface SkillRemoveArgs {
+	skill: string;
+	plugin: string;
+}
+
+export async function planSkillRemove(
+	args: SkillRemoveArgs,
+	cwd: string,
+): Promise<PlanAnswer> {
+	const command: MarketCommand = "market skill remove";
+	try {
+		checkSkillName(args.skill);
+		const view = await readPlugin(args.plugin);
+		const { m, snap, plugin, dir } = view;
+		const skillDir = joinRel(dir, "skills", args.skill);
+		const under = filesUnder(snap, skillDir);
+		if (!snap.entries.has(joinRel(skillDir, "SKILL.md"))) {
+			throw new MarketError(
+				"not-found",
+				`${plugin}@${m.name} has no skill named ${args.skill}`,
+			);
+		}
+		const { from, to } = bumpFrom(view);
+		const target = await deliveryTarget(m.source, m.name);
+		const pluginId = `${plugin}@${m.name}`;
+		const installs = await installedScopes(pluginId, cwd);
+		const locals = (["project", "global"] as const)
+			.map((w) => ({ where: w, folder: skillFolder(cwd, w, args.skill) }))
+			.filter((l) => fs.existsSync(l.folder));
+		const files = [
+			...under.map((f) => ({
+				path: joinRel(skillDir, f.path),
+				change: "deleted" as const,
+			})),
+			...versionFiles(view),
+		];
+		const state: ChangeSpec["state"] & { moved?: boolean } = {};
+		const firstLocal = locals[0];
+		const kept: LocalCopy | undefined = firstLocal
+			? {
+					scope: firstLocal.where === "global" ? "user" : "project",
+					name: args.skill,
+					action: "kept",
+					reason:
+						"the plugin no longer holds this skill, so this copy is the only one left",
+				}
+			: undefined;
+		const steps: MarketStep[] = [
+			{
+				id: "remove",
+				label: `removed ${args.skill} from ${plugin}`,
+				outside: false,
+				async run(ctx) {
+					removeUnder(cloneOf(ctx), skillDir, linkRefusal(m.name));
+					return undefined;
+				},
+			},
+			bumpStep(view, to),
+			...changeSteps({
+				label: m.name,
+				source: m.source,
+				branch: snap.branch,
+				target,
+				stage: [skillDir, ...versionFiles(view).map((f) => f.path)],
+				files,
+				message: `${plugin}: remove ${args.skill} skill (${to})`,
+				slug: `${plugin}-${to}`,
+				prBody: `Removes the skill \`${args.skill}\` from \`${plugin}\` and bumps it to ${to}.`,
+				state,
+			}),
+			installStep(view, installs, to, state),
+			{
+				id: "bases",
+				label: "forgot where local copies of the skill came from",
+				outside: true,
+				async run() {
+					// Only this plugin's records: a same-named folder copied from
+					// another plugin keeps its own.
+					forgetBasesFor(m.name, { plugin, skill: args.skill });
+					return kept ? { patch: { localCopy: kept } } : undefined;
+				},
+			},
+		];
+		const lines = [
+			`Removes the skill ${args.skill} from ${pluginId}: ${under.length} file${under.length === 1 ? "" : "s"}`,
+			versionLine(plugin, from, to),
+			targetLine(target, snap.branch),
+			...installLines(plugin, installs, to),
+			...locals.map(
+				(l) =>
+					`Keeps ${l.where === "global" ? "your USER" : "this project's"} copy of ${args.skill}: it is the only one left`,
+			),
+		];
+		const plan: MarketPlan = {
+			command,
+			lines,
+			planId: computePlanId({
+				op: "skill-remove",
+				skill: args.skill,
+				plugin: pluginId,
+				commit: snap.commit,
+				target,
+				version: { from, to },
+				installs,
+				locals: locals.map((l) => l.where),
+			}),
+			summary: {
+				marketplace: m.name,
+				plugin,
+				skill: args.skill,
+				version: { from, to },
+				files,
+				target,
+			},
+			steps,
+			sync: { name: m.name, url: cloneUrl(m.source) },
+			lock: m.name,
+			replan: () => planSkillRemove(args, cwd),
+			doneMessage: `${args.skill} is no longer in ${pluginId} ${to}. Takes effect in new sessions, or after /reload-plugins.`,
+		};
+		return { kind: "plan", plan };
+	} catch (error) {
+		return planError(command, error);
+	}
+}