universal-plugin 0.4.0 → 0.6.0

package/dist/cli.mjs

@@ -1,17 +1,33 @@
 #!/usr/bin/env node
 import { Command, Option } from "commander";
-import * as fsNode from "node:fs";
+import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { encode } from "@toon-format/toon";
-import { fileURLToPath } from "node:url";
+import * as semver$1 from "semver";
+import semver from "semver";
 import * as childProcess from "node:child_process";
-import * as semver from "semver";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 //#region src/cli-options.ts
 /** Repo root; resolves to cwd when omitted. */
 const ROOT_OPTION = new Option("--root <path>", "Plugin root directory");
-function resolveRoot(root) {
-	return root ?? process.cwd();
+/** Resolves `--root` to an absolute directory. Every command reports and joins against this path,
+*  so it must name a real directory rather than a fragment of one.
+*
+*  A relative root resolves against the cwd, with one repair: in a monorepo a package is named by
+*  its workspace-relative path (`packages/pods`), and passing that from inside the package itself
+*  re-joins it onto a cwd that already ends with it — `<repo>/packages/pods/packages/pods`, a
+*  directory that does not exist. When the re-joined path is missing and the cwd already ends with
+*  the given path, the cwd is the package that was named. */
+function resolveRoot(root, deps = {}) {
+	const cwd = deps.cwd ?? process.cwd();
+	const exists = deps.exists ?? ((candidate) => fs.existsSync(candidate));
+	if (root === void 0) return cwd;
+	const resolved = path.resolve(cwd, root);
+	if (path.isAbsolute(root) || exists(resolved)) return resolved;
+	const relative = path.normalize(root).replace(new RegExp(`\\${path.sep}+$`), "");
+	return cwd.endsWith(path.sep + relative) ? cwd : resolved;
 }
 //#endregion
 //#region src/state/state.ts
@@ -109,19 +125,19 @@ function storeEntryPath(storePath, segment) {
 //#endregion
 //#region src/asset-store/fs.ts
 function entryExists(entryPath) {
-	return fsNode.existsSync(entryPath);
+	return fs.existsSync(entryPath);
 }
 function populateEntry(entryPath, pluginRoot) {
 	for (const dir of ASSET_DIRS) {
 		const src = path.join(pluginRoot, dir);
 		const dest = path.join(entryPath, dir);
-		if (!fsNode.existsSync(src)) continue;
-		fsNode.mkdirSync(dest, { recursive: true });
-		for (const file of fsNode.readdirSync(src)) fsNode.copyFileSync(path.join(src, file), path.join(dest, file));
+		if (!fs.existsSync(src)) continue;
+		fs.mkdirSync(dest, { recursive: true });
+		for (const file of fs.readdirSync(src)) fs.copyFileSync(path.join(src, file), path.join(dest, file));
 	}
 }
 function removeStore(storePath) {
-	fsNode.rmSync(storePath, {
+	fs.rmSync(storePath, {
 		recursive: true,
 		force: true
 	});
@@ -134,11 +150,11 @@ function globalStatePath$3() {
 function clearStateIndex(statePath) {
 	try {
 		const cleared = {
-			...mergeSafeState(JSON.parse(fsNode.readFileSync(statePath, "utf8"))),
+			...mergeSafeState(JSON.parse(fs.readFileSync(statePath, "utf8"))),
 			plugins: {},
 			assets: {}
 		};
-		fsNode.writeFileSync(statePath, JSON.stringify(cleared, null, 2) + "\n", "utf8");
+		fs.writeFileSync(statePath, JSON.stringify(cleared, null, 2) + "\n", "utf8");
 	} catch (err) {
 		if (err.code !== "ENOENT") throw err;
 	}
@@ -184,6 +200,197 @@ function outputText(data, text) {
 	else text();
 }
 //#endregion
+//#region src/dependencies/dependencies.ts
+/** Plugin dependencies: one canonical declaration of the plugins this plugin needs, delivered to the
+*  vendors that read one and dropped with a warning for the vendors that do not (ADR-0013).
+*
+*  The canonical form is Claude Code's, because Claude Code is the only runtime that reads a
+*  dependency at all: an array whose entries are a plugin name — optionally `@marketplace`-qualified
+*  — or an object carrying that name plus a constraint. Pure domain code; reading and writing the
+*  manifests belongs to the build. */
+/** Vendors that read a `dependencies` field. Sources, re-verified August 2026:
+*  Claude Code 2.1.235 (`claude plugin validate` accepts every form below, and its resolver installs,
+*  enables, and version-checks what it finds); Cursor 2026.07.01 and Codex 0.147.0 both parse a plugin
+*  manifest with no such field; GitHub Copilot CLI documents none
+*  (docs.github.com/en/copilot/reference/copilot-cli-reference/cli-plugin-reference).
+*  `.research/plugin-schema/` carries the evidence and the recheck triggers. */
+const VENDOR_READS_DEPENDENCIES = {
+	"claude-code": true,
+	cursor: false,
+	codex: false,
+	"copilot-cli": false
+};
+/** Vendors the canonical root manifest serves as-is: nothing is derived for them, so a declaration
+*  they cannot read is ignored at runtime rather than dropped from a file. */
+const CANONICAL_SERVED$1 = new Set(["copilot-cli"]);
+/** What Claude Code accepts as a dependency string: a plugin name, an optional `@marketplace`, and an
+*  optional `@^…` range tail that the runtime strips before resolving. */
+const DEPENDENCY_STRING = /^[A-Za-z0-9][-A-Za-z0-9._]*(@[A-Za-z0-9][-A-Za-z0-9._]*)?(@\^[^@]*)?$/;
+const RANGE_TAIL = /@(\^[^@]*)$/;
+/** Checks the shape of a `dependencies` declaration. Errors are author mistakes the runtime would
+*  reject; warnings are declarations the runtime accepts and then quietly ignores. */
+function validateDependencies(declaration) {
+	const errors = [];
+	const warnings = [];
+	if (declaration === void 0 || declaration === null) return {
+		errors,
+		warnings
+	};
+	if (!Array.isArray(declaration)) {
+		errors.push("dependencies must be an array of plugin names or objects, not an object map");
+		return {
+			errors,
+			warnings
+		};
+	}
+	declaration.forEach((entry, index) => {
+		if (typeof entry === "string") {
+			if (!DEPENDENCY_STRING.test(entry)) {
+				errors.push(`dependencies[${index}] "${entry}" is not a plugin name, optionally qualified with @marketplace`);
+				return;
+			}
+			const range = entry.match(RANGE_TAIL)?.[1];
+			if (range) warnings.push(discardedRangeWarning(index, entry, range));
+			return;
+		}
+		if (!isDependencyObject(entry)) {
+			errors.push(`dependencies[${index}] must be a plugin name or an object with a name`);
+			return;
+		}
+		if (!DEPENDENCY_STRING.test(dependencyId(entry))) errors.push(`dependencies[${index}] "${dependencyId(entry)}" is not a plugin name, optionally qualified with @marketplace`);
+		if (entry.version !== void 0 && semver.validRange(entry.version) === null) errors.push(`dependencies[${index}].version "${entry.version}" is not a semver range`);
+	});
+	return {
+		errors,
+		warnings
+	};
+}
+/** Derives the `dependencies` field one vendor's manifest carries. */
+function translateDependencies(declaration, vendor) {
+	if (declaration.length === 0) return {
+		dependencies: null,
+		warnings: []
+	};
+	if (VENDOR_READS_DEPENDENCIES[vendor] !== false) return {
+		dependencies: declaration,
+		warnings: []
+	};
+	return {
+		dependencies: null,
+		warnings: [`${vendor} does not read plugin dependencies — ${declaration.map((entry) => `"${dependencyId(entry)}"`).join(", ")} ${declaration.length === 1 ? "is" : "are"} ${CANONICAL_SERVED$1.has(vendor) ? "ignored at runtime" : "dropped from the derived manifest"}`]
+	};
+}
+/** The `name[@marketplace]` a runtime resolves a declaration to, minus any constraint beside it. */
+function dependencyId(entry) {
+	if (typeof entry === "string") return entry.replace(RANGE_TAIL, "");
+	return entry.marketplace ? `${entry.name}@${entry.marketplace}` : entry.name;
+}
+function isDependencyObject(entry) {
+	return typeof entry === "object" && entry !== null && !Array.isArray(entry) && typeof entry.name === "string" && entry.name.length > 0;
+}
+/** A range in the string form parses and is then thrown away: Claude Code strips the `@^…` tail
+*  before resolving, and reads a constraint only off the object form. Naming the object the author
+*  meant to write is the whole remedy. */
+function discardedRangeWarning(index, entry, range) {
+	const [name, marketplace] = entry.replace(RANGE_TAIL, "").split("@");
+	return `dependencies[${index}] "${entry}" carries a version range the runtime discards — declare ${marketplace ? `{ "name": "${name}", "marketplace": "${marketplace}", "version": "${range}" }` : `{ "name": "${name}", "version": "${range}" }`} for a range that is enforced`;
+}
+//#endregion
+//#region src/hooks/hooks.ts
+/** Per-vendor hook support. Source: `.research/hook-event-survey/conclusion.md`, re-verified against
+*  vendor documentation August 2026. A vendor fact decays — re-verify before trusting this table. */
+const VENDOR_HOOK_PROFILE = {
+	"claude-code": {
+		casing: "pascal",
+		shape: "matcher-groups",
+		handlers: [
+			"command",
+			"http",
+			"prompt",
+			"agent"
+		]
+	},
+	codex: {
+		casing: "pascal",
+		shape: "matcher-groups",
+		handlers: ["command"]
+	},
+	cursor: {
+		casing: "camel",
+		shape: "flat",
+		handlers: ["command", "prompt"],
+		schemaVersion: 1
+	},
+	"copilot-cli": {
+		casing: "pascal",
+		shape: "matcher-groups",
+		handlers: [
+			"command",
+			"http",
+			"prompt"
+		]
+	}
+};
+function translateHooks(canonical, vendor) {
+	const profile = VENDOR_HOOK_PROFILE[vendor];
+	if (!profile) return {
+		hooks: canonical,
+		drops: [],
+		changed: false
+	};
+	const drops = [];
+	const events = {};
+	for (const [event, rules] of Object.entries(canonical.hooks ?? {})) {
+		const kept = [];
+		for (const rule of rules) {
+			const handlers = rule.hooks.filter((handler) => {
+				const type = handlerType(handler);
+				if (profile.handlers.includes(type)) return true;
+				drops.push({
+					event,
+					type
+				});
+				return false;
+			});
+			if (handlers.length > 0) kept.push({
+				...rule,
+				hooks: handlers
+			});
+		}
+		if (kept.length === 0) continue;
+		events[eventName(event, profile.casing)] = profile.shape === "flat" ? flatten(kept) : kept;
+	}
+	if (Object.keys(events).length === 0) return {
+		hooks: null,
+		drops,
+		changed: true
+	};
+	const hooks = profile.schemaVersion === void 0 ? { hooks: events } : {
+		version: profile.schemaVersion,
+		hooks: events
+	};
+	return {
+		hooks,
+		drops,
+		changed: JSON.stringify(hooks) !== JSON.stringify(canonical)
+	};
+}
+/** A handler with no declared type is a command — the canonical schema's only required-by-default shape. */
+function handlerType(handler) {
+	return handler.type ?? "command";
+}
+function eventName(event, casing) {
+	return casing === "camel" ? event.charAt(0).toLowerCase() + event.slice(1) : event;
+}
+/** Cursor has no matcher-group level: one group of N handlers becomes N entries, each repeating the
+*  group's matcher. */
+function flatten(rules) {
+	return rules.flatMap((rule) => rule.hooks.map((handler) => rule.matcher === void 0 ? handler : {
+		...handler,
+		matcher: rule.matcher
+	}));
+}
+//#endregion
 //#region src/json.ts
 /** Detects indentation style from JSON text. Returns `'\t'` for tabs or a number for space count.
 *  Falls back to `'\t'` when no indentation is detected. */
@@ -193,6 +400,517 @@ function detectIndent(json) {
 	return match[1].startsWith("	") ? "	" : match[1].length;
 }
 //#endregion
+//#region src/marketplace/marketplace.ts
+/** Claude Code ignores `$schema` at load time; it is there for editor completion and for
+*  `claude plugin validate`. Cursor documents no schema key, so only Claude's catalog carries one. */
+const CLAUDE_SCHEMA = "https://json.schemastore.org/claude-code-marketplace.json";
+/** Where each target's catalog sits, relative to the repository root. One place, because the
+*  generator writes these paths and `plugin init` reads the same ones to fold its entry in. */
+const TARGET_CATALOG_PATHS = {
+	claude: ".claude-plugin/marketplace.json",
+	cursor: ".cursor-plugin/marketplace.json",
+	codex: ".agents/plugins/marketplace.json",
+	copilot: ".github/plugin/marketplace.json"
+};
+const COMMON_METADATA = [
+	"description",
+	"version",
+	"homepage",
+	"repository",
+	"license",
+	"keywords"
+];
+function assertMarketplaceName(value, label) {
+	if (!/^[a-z0-9][a-z0-9._-]*$/i.test(value)) throw new Error(`error: ${label} "${value}" must contain only letters, digits, dots, underscores, or hyphens`);
+}
+/** A manifest field carried into a catalog entry, in the shape the catalog schema states. A manifest
+*  written from a `package.json` carries `repository` as `{ type, url }`, and every catalog wants the
+*  URL alone — Claude Code rejects the object (`plugins[].repository: expected string`). A value that
+*  cannot be reduced to the right type is dropped rather than written: an entry missing an optional
+*  field still installs, an entry with the wrong type installs nowhere. */
+function catalogValue(field, value) {
+	if (field === "keywords") return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+	if (field === "repository" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+		const url = value.url;
+		return typeof url === "string" ? url.replace(/^git\+/, "") : void 0;
+	}
+	return typeof value === "string" ? value : void 0;
+}
+function commonMetadata(plugin) {
+	const result = {};
+	for (const field of COMMON_METADATA) {
+		if (plugin.metadata[field] === void 0) continue;
+		const value = catalogValue(field, plugin.metadata[field]);
+		if (value !== void 0) result[field] = value;
+	}
+	return result;
+}
+function json(value) {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+function claudeArtifact(metadata, plugins) {
+	return {
+		path: TARGET_CATALOG_PATHS.claude,
+		content: json({
+			$schema: CLAUDE_SCHEMA,
+			...metadata,
+			plugins: plugins.map((plugin) => ({
+				name: plugin.name,
+				source: plugin.source,
+				...commonMetadata(plugin)
+			}))
+		})
+	};
+}
+function codexArtifact(metadata, plugins) {
+	return {
+		path: TARGET_CATALOG_PATHS.codex,
+		content: json({
+			name: metadata.name,
+			interface: { displayName: metadata.name },
+			plugins: plugins.map((plugin) => ({
+				name: plugin.name,
+				version: plugin.metadata.version,
+				source: {
+					source: "local",
+					path: plugin.source
+				},
+				policy: {
+					installation: "AVAILABLE",
+					authentication: "ON_INSTALL"
+				},
+				category: "Productivity"
+			}))
+		})
+	};
+}
+function copilotArtifact(metadata, plugins) {
+	return {
+		path: TARGET_CATALOG_PATHS.copilot,
+		content: json({
+			...metadata,
+			metadata: { displayName: metadata.name },
+			plugins: plugins.map((plugin) => ({
+				name: plugin.name,
+				source: plugin.source,
+				...commonMetadata(plugin)
+			}))
+		})
+	};
+}
+/** Cursor reads `.cursor-plugin/marketplace.json` at the repository root, with a shape close to
+*  Claude Code's. It is not an install path for the author: a developer tests through
+*  `~/.cursor/plugins/local/<name>`, and the catalog reaches users when an admin imports the
+*  repository as a team marketplace (`.research/local-marketplaces`, E-CUR-M3, E-CUR-M4). */
+function cursorArtifact(metadata, plugins) {
+	return {
+		path: TARGET_CATALOG_PATHS.cursor,
+		content: json({
+			...metadata,
+			plugins: plugins.map((plugin) => ({
+				name: plugin.name,
+				source: plugin.source,
+				...commonMetadata(plugin)
+			}))
+		})
+	};
+}
+/** The marketplace target each `--vendor` id catalogs into. Every vendor documents a
+*  repository-local catalog (`.research/local-marketplaces`). */
+const VENDOR_TARGETS = {
+	"claude-code": "claude",
+	cursor: "cursor",
+	codex: "codex",
+	"copilot-cli": "copilot"
+};
+/** Folds one plugin's entry into a catalog that may already exist, and returns the artifact to
+*  write. An existing catalog keeps its own top-level fields — its name, its owner, a description
+*  someone wrote — and every entry it lists for other plugins, in place. Only this plugin's entry is
+*  re-derived.
+*
+*  `version` is derived, never authored (ADR-0010 §3): the entry carries whatever the canonical
+*  manifest carries, and a version left behind on an entry whose manifest declares none is removed
+*  rather than kept. */
+function mergeCatalogEntry(target, metadata, plugin, readExisting) {
+	const artifact = serializeTarget(target, metadata, [plugin])[0];
+	const existing = readExisting(artifact.path);
+	if (existing === void 0) return artifact;
+	const previous = parseCatalog(existing, artifact.path);
+	const generated = JSON.parse(artifact.content);
+	const entry = generated.plugins[0];
+	const merged = { ...previous };
+	for (const [key, value] of Object.entries(generated)) if (!(key in merged)) merged[key] = value;
+	merged.plugins = mergeEntries(previous, entry);
+	return {
+		path: artifact.path,
+		content: json(merged)
+	};
+}
+function parseCatalog(content, path) {
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch {
+		throw new Error(`error: existing catalog "${path}" is not valid JSON`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`error: existing catalog "${path}" is not a JSON object`);
+	return parsed;
+}
+function mergeEntries(previous, entry) {
+	const entries = Array.isArray(previous.plugins) ? [...previous.plugins] : [];
+	const index = entries.findIndex((candidate) => typeof candidate === "object" && candidate !== null && candidate.name === entry.name);
+	if (index === -1) return [...entries, entry];
+	const merged = {
+		...entries[index],
+		...entry
+	};
+	if (!("version" in entry)) delete merged.version;
+	entries[index] = merged;
+	return entries;
+}
+/** The catalog's own top-level identity, read back from the file the repository already carries, so
+*  a refresh re-derives one entry without proposing a name or an owner of its own. */
+function existingMetadata(previous) {
+	const name = typeof previous.name === "string" ? previous.name : "";
+	const owner = previous.owner;
+	if (typeof owner === "object" && owner !== null && typeof owner.name === "string") return {
+		name,
+		owner
+	};
+	return {
+		name,
+		owner: { name }
+	};
+}
+/** Re-derives one plugin's entry inside a catalog the repository already carries. Update only, in two
+*  senses: it never creates a catalog — `plugin init --vendor` and `marketplace init` own that — and
+*  it adds nothing to the catalog's top level, not even a `$schema` the file happens to lack. Only
+*  the entry changes, so a build can run it unconditionally (ADR-0014). */
+function refreshCatalogEntry(target, plugin, existing) {
+	const catalogPath = TARGET_CATALOG_PATHS[target];
+	const previous = parseCatalog(existing, catalogPath);
+	const entry = JSON.parse(serializeTarget(target, existingMetadata(previous), [plugin])[0]?.content ?? "{}").plugins[0];
+	return {
+		path: catalogPath,
+		content: json({
+			...previous,
+			plugins: mergeEntries(previous, entry)
+		})
+	};
+}
+/** Whether two catalogs say the same thing. Key order and whitespace do not change a catalog's
+*  meaning — the repository formats its own JSON — so a refresh compares this rather than bytes and
+*  leaves a file it agrees with alone. Array order does count. */
+function sameCatalogContent(a, b) {
+	try {
+		return JSON.stringify(canonicalJson(JSON.parse(a))) === JSON.stringify(canonicalJson(JSON.parse(b)));
+	} catch {
+		return false;
+	}
+}
+function canonicalJson(value) {
+	if (Array.isArray(value)) return value.map(canonicalJson);
+	if (typeof value !== "object" || value === null) return value;
+	const record = value;
+	return Object.fromEntries(Object.keys(record).sort().map((key) => [key, canonicalJson(record[key])]));
+}
+function serializeTarget(target, metadata, plugins) {
+	switch (target) {
+		case "claude": return [claudeArtifact(metadata, plugins)];
+		case "codex": return [codexArtifact(metadata, plugins)];
+		case "copilot": return [copilotArtifact(metadata, plugins)];
+		case "cursor": return [cursorArtifact(metadata, plugins)];
+	}
+}
+//#endregion
+//#region src/marketplace/fs.ts
+const realMarketplaceFs = {
+	exists: fs.existsSync,
+	isDirectory(file) {
+		return fs.statSync(file).isDirectory();
+	},
+	realpath(file) {
+		return fs.realpathSync(file);
+	},
+	read(file) {
+		return fs.readFileSync(file, "utf8");
+	},
+	listEntries(dir) {
+		return fs.readdirSync(dir);
+	},
+	writeAtomically(file, content) {
+		fs.mkdirSync(path.dirname(file), { recursive: true });
+		const temporary = `${file}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+		fs.writeFileSync(temporary, content);
+		fs.renameSync(temporary, file);
+	}
+};
+function gitToplevel(root) {
+	try {
+		const top = execFileSync("git", [
+			"-C",
+			root,
+			"rev-parse",
+			"--show-toplevel"
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return top === "" ? void 0 : path.resolve(top);
+	} catch {
+		return;
+	}
+}
+function gatherCatalogRepo(root) {
+	const repoRoot = gitToplevel(root);
+	if (!repoRoot) return void 0;
+	const relative = path.relative(repoRoot, root);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) return void 0;
+	const catalogs = {};
+	for (const catalog of Object.values(TARGET_CATALOG_PATHS)) {
+		const file = path.join(repoRoot, catalog);
+		if (fs.existsSync(file)) catalogs[catalog] = fs.readFileSync(file, "utf8");
+	}
+	return {
+		root: repoRoot,
+		pluginPath: relative.split(path.sep).join("/"),
+		catalogs
+	};
+}
+//#endregion
+//#region src/marketplace/validation.ts
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function typeName(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+function checkString(issues, path, value, { required = false } = {}) {
+	if (value === void 0) {
+		if (required) issues.push({
+			path,
+			message: "is required"
+		});
+		return;
+	}
+	if (typeof value !== "string") {
+		issues.push({
+			path,
+			message: `must be a string, not ${typeName(value)}`
+		});
+		return;
+	}
+	if (required && value.trim() === "") issues.push({
+		path,
+		message: "must not be empty"
+	});
+}
+function checkStringArray(issues, path, value) {
+	if (value === void 0) return;
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: `must be an array of strings, not ${typeName(value)}`
+		});
+		return;
+	}
+	value.forEach((item, index) => {
+		checkString(issues, `${path}[${index}]`, item);
+	});
+}
+/** `owner` and a plugin's `author` share one shape: an object carrying a required `name`. A string
+*  there is the mistake `package.json`'s `"author": "Name <email>"` invites; Claude Code reports
+*  `expected object, received string` and refuses the catalog. */
+function checkPerson(issues, path, value, { required = false } = {}) {
+	if (value === void 0) {
+		if (required) issues.push({
+			path,
+			message: "is required"
+		});
+		return;
+	}
+	if (!isObject(value)) {
+		const remedy = typeof value === "string" ? ` — write { "name": ${JSON.stringify(value)} }` : "";
+		issues.push({
+			path,
+			message: `must be an object with a name, not ${typeName(value)}${remedy}`
+		});
+		return;
+	}
+	checkString(issues, `${path}.name`, value.name, { required: true });
+	checkString(issues, `${path}.email`, value.email);
+	checkString(issues, `${path}.url`, value.url);
+}
+/** The source forms the official schema accepts: a `./`-prefixed repository-relative path, or one of
+*  the tagged remote objects. */
+const REMOTE_SOURCE_KEYS = {
+	npm: ["package"],
+	url: ["url"],
+	github: ["repo"],
+	"git-subdir": ["url", "path"]
+};
+function checkClaudeSource(issues, path, value) {
+	if (value === void 0) {
+		issues.push({
+			path,
+			message: "is required"
+		});
+		return;
+	}
+	if (typeof value === "string") {
+		if (!value.startsWith("./")) issues.push({
+			path,
+			message: `must be a "./"-prefixed repository-relative path, not ${JSON.stringify(value)}`
+		});
+		return;
+	}
+	if (!isObject(value)) {
+		issues.push({
+			path,
+			message: `must be a "./" path or a source object, not ${typeName(value)}`
+		});
+		return;
+	}
+	const kind = value.source;
+	if (typeof kind !== "string" || !(kind in REMOTE_SOURCE_KEYS)) {
+		issues.push({
+			path: `${path}.source`,
+			message: `must be one of ${Object.keys(REMOTE_SOURCE_KEYS).join(", ")}`
+		});
+		return;
+	}
+	for (const key of REMOTE_SOURCE_KEYS[kind]) checkString(issues, `${path}.${key}`, value[key], { required: true });
+}
+function checkClaudeEntry(issues, path, entry) {
+	if (!isObject(entry)) {
+		issues.push({
+			path,
+			message: `must be an object, not ${typeName(entry)}`
+		});
+		return;
+	}
+	checkString(issues, `${path}.name`, entry.name, { required: true });
+	checkClaudeSource(issues, `${path}.source`, entry.source);
+	checkString(issues, `${path}.version`, entry.version);
+	checkString(issues, `${path}.description`, entry.description);
+	checkString(issues, `${path}.homepage`, entry.homepage);
+	if (isObject(entry.repository) && typeof entry.repository.url === "string") issues.push({
+		path: `${path}.repository`,
+		message: `must be a string, not object — write ${JSON.stringify(entry.repository.url)}`
+	});
+	else checkString(issues, `${path}.repository`, entry.repository);
+	checkString(issues, `${path}.license`, entry.license);
+	checkString(issues, `${path}.category`, entry.category);
+	checkPerson(issues, `${path}.author`, entry.author);
+	checkStringArray(issues, `${path}.keywords`, entry.keywords);
+	checkStringArray(issues, `${path}.tags`, entry.tags);
+}
+function validateClaudeShaped(catalog) {
+	const issues = [];
+	checkString(issues, "name", catalog.name, { required: true });
+	checkPerson(issues, "owner", catalog.owner, { required: true });
+	checkString(issues, "description", catalog.description);
+	checkString(issues, "version", catalog.version);
+	if (catalog.plugins === void 0) {
+		issues.push({
+			path: "plugins",
+			message: "is required"
+		});
+		return issues;
+	}
+	if (!Array.isArray(catalog.plugins)) {
+		issues.push({
+			path: "plugins",
+			message: `must be an array, not ${typeName(catalog.plugins)}`
+		});
+		return issues;
+	}
+	catalog.plugins.forEach((entry, index) => {
+		checkClaudeEntry(issues, `plugins[${index}]`, entry);
+	});
+	return issues;
+}
+/** Codex reads a document of its own: no `owner`, a display name under `interface`, and an object
+*  `source` naming a local path (`.research/local-marketplaces`, E-CODEX-M11). It tolerates extra
+*  keys and requires no entry `version`. */
+function validateCodex(catalog) {
+	const issues = [];
+	checkString(issues, "name", catalog.name, { required: true });
+	if (catalog.interface !== void 0 && !isObject(catalog.interface)) issues.push({
+		path: "interface",
+		message: `must be an object, not ${typeName(catalog.interface)}`
+	});
+	else if (isObject(catalog.interface)) checkString(issues, "interface.displayName", catalog.interface.displayName);
+	if (catalog.plugins === void 0) {
+		issues.push({
+			path: "plugins",
+			message: "is required"
+		});
+		return issues;
+	}
+	if (!Array.isArray(catalog.plugins)) {
+		issues.push({
+			path: "plugins",
+			message: `must be an array, not ${typeName(catalog.plugins)}`
+		});
+		return issues;
+	}
+	catalog.plugins.forEach((entry, index) => {
+		const path = `plugins[${index}]`;
+		if (!isObject(entry)) {
+			issues.push({
+				path,
+				message: `must be an object, not ${typeName(entry)}`
+			});
+			return;
+		}
+		checkString(issues, `${path}.name`, entry.name, { required: true });
+		checkString(issues, `${path}.version`, entry.version);
+		checkString(issues, `${path}.category`, entry.category);
+		if (typeof entry.source === "string") checkClaudeSource(issues, `${path}.source`, entry.source);
+		else if (isObject(entry.source)) {
+			checkString(issues, `${path}.source.source`, entry.source.source, { required: true });
+			if (entry.source.source === "local") checkClaudeSource(issues, `${path}.source.path`, entry.source.path);
+		} else issues.push({
+			path: `${path}.source`,
+			message: "is required"
+		});
+	});
+	return issues;
+}
+/** Every issue a target's runtime would raise against this catalog, empty when it loads. */
+function validateCatalog(target, catalog) {
+	if (!isObject(catalog)) return [{
+		path: "",
+		message: `catalog must be a JSON object, not ${typeName(catalog)}`
+	}];
+	return target === "codex" ? validateCodex(catalog) : validateClaudeShaped(catalog);
+}
+/** The same check against a catalog still in its serialized form. Text that does not parse is one
+*  issue rather than a thrown error, so a caller checking four files reports all four. */
+function validateCatalogContent(target, content) {
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch (err) {
+		return [{
+			path: "",
+			message: `is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+		}];
+	}
+	return validateCatalog(target, parsed);
+}
+/** One error message naming the file and every issue in it, for a caller that fails loud. */
+function formatCatalogIssues(file, issues) {
+	return `error: catalog "${file}" does not match the marketplace schema:\n${issues.map((issue) => `  ${issue.path === "" ? file : `${issue.path}`} ${issue.message}`).join("\n")}`;
+}
+//#endregion
 //#region src/build/build.ts
 /** Where each vendor reads its manifest, relative to the project root. Shared with
 *  `plugin init --npm`, which wires exactly these paths into `package.json` `files`. */
@@ -206,6 +924,9 @@ const KNOWN_VENDORS = new Set(Object.keys(VENDOR_OUTPUT));
 /** Vendors the canonical root manifest serves as-is. The build derives no file for these — writing
 *  one would either be shadowed by root (a lower-precedence path) or clobber root itself. */
 const CANONICAL_SERVED = new Set(["copilot-cli"]);
+/** Where every vendor looks for a plugin's hooks when the manifest declares none
+*  (`.research/hook-event-survey/conclusion.md`). */
+const DEFAULT_HOOKS_PATH = "./hooks/hooks.json";
 const UP_NAMESPACE$1 = "org.cyberuni.universal-plugin";
 /** Reads universal-plugin's config block from the canonical manifest's extensions map. */
 function universalPluginExtension(manifest) {
@@ -213,8 +934,8 @@ function universalPluginExtension(manifest) {
 }
 function readManifest(root) {
 	const manifestPath = path.join(root, "plugin.json");
-	if (!fsNode.existsSync(manifestPath)) throw new Error(`No plugin.json found at ${root}`);
-	return JSON.parse(fsNode.readFileSync(manifestPath, "utf8"));
+	if (!fs.existsSync(manifestPath)) throw new Error(`No plugin.json found at ${root}`);
+	return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
 }
 /** Validates the manifest. Vendor rules apply only to the vendors actually being built: pass
 *  `targets` to scope the check (build passes its selected targets), else it defaults to the
@@ -227,12 +948,13 @@ function validateManifest(manifest, targets) {
 	const codexTargeted = (targets ?? uext.vendors ?? Object.keys(harnesses)).includes("codex") && Boolean(harnesses["codex"]);
 	if (codexTargeted && !manifest.description) errors.push("description is required when targeting codex");
 	if (codexTargeted && !manifest.version) errors.push("version is required when targeting codex");
+	errors.push(...validateDependencies(uext.dependencies).errors);
 	return errors;
 }
 function buildPlugin(root, opts = {}) {
 	const manifestPath = path.join(root, "plugin.json");
-	if (!fsNode.existsSync(manifestPath)) throw new Error(`No plugin.json found at ${root}`);
-	const indent = detectIndent(fsNode.readFileSync(manifestPath, "utf8"));
+	if (!fs.existsSync(manifestPath)) throw new Error(`No plugin.json found at ${root}`);
+	const indent = detectIndent(fs.readFileSync(manifestPath, "utf8"));
 	const manifest = readManifest(root);
 	const warnings = [];
 	const rows = [];
@@ -261,6 +983,7 @@ function buildPlugin(root, opts = {}) {
 			written: [],
 			warnings,
 			rows,
+			catalogs: [],
 			summary: summarize(rows)
 		};
 	}
@@ -268,8 +991,10 @@ function buildPlugin(root, opts = {}) {
 	if (errors.length > 0) throw new Error(`plugin.json validation failed:\n${errors.map((e) => `  - ${e}`).join("\n")}`);
 	const written = [];
 	const { $schema: _schema, extensions: _extensions, ...metadata } = manifest;
-	const { vendors: _vendors, packagePath: _packagePath, harnesses: _harnesses, ...componentConfig } = uext;
+	const { vendors: _vendors, packagePath: _packagePath, harnesses: _harnesses, dependencies: declaredDependencies, ...componentConfig } = uext;
+	warnings.push(...validateDependencies(declaredDependencies).warnings);
 	const skills = readSkills(root, manifest);
+	const canonicalHooks = readCanonicalHooks(root, componentConfig["hooks"], warnings);
 	for (const vendor of vendors) {
 		const relPath = VENDOR_OUTPUT[vendor];
 		const outputPath = path.join(root, relPath);
@@ -280,10 +1005,15 @@ function buildPlugin(root, opts = {}) {
 			...componentConfig,
 			...vendorFields
 		};
+		const hooks = canonicalHooks ? translateHooks(canonicalHooks, vendor) : null;
+		const dependencies = translateDependencies(declaredDependencies ?? [], vendor);
+		warnings.push(...dependencies.warnings);
+		if (dependencies.dependencies) vendorManifest["dependencies"] = dependencies.dependencies;
 		if (CANONICAL_SERVED.has(vendor)) {
+			for (const drop of dedupeDrops(hooks?.drops ?? [])) warnings.push(`${vendor} cannot run the "${drop.type}" hook handler on ${drop.event} — it is ignored at runtime`);
 			const overrides = Object.keys(vendorFields);
 			if (overrides.length > 0) warnings.push(`harnesses.${vendor} sets ${overrides.join(", ")}, but ${vendor} reads the canonical plugin.json directly — these fields are not delivered`);
-			writeSkillArtifacts(root, vendor, skills, opts, written, warnings);
+			writeSkillArtifacts(vendor, skills, opts, written, warnings);
 			rows.push({
 				vendor,
 				path: relPath,
@@ -291,18 +1021,26 @@ function buildPlugin(root, opts = {}) {
 			});
 			continue;
 		}
+		for (const drop of dedupeDrops(hooks?.drops ?? [])) warnings.push(`${vendor} cannot run the "${drop.type}" hook handler on ${drop.event} — dropped from the derived hooks file`);
+		const derivedHooksPath = path.join(outputDir, "hooks.json");
+		if (hooks?.changed) if (hooks.hooks) vendorManifest["hooks"] = `./${path.dirname(relPath).split(path.sep).join("/")}/hooks.json`;
+		else delete vendorManifest["hooks"];
 		if (opts.verbose) {
 			console.log(`[${vendor}] → ${outputPath}`);
 			for (const key of Object.keys(vendorFields)) console.log(`  + ${key} (from harnesses.${vendor})`);
 		}
 		try {
 			if (!opts.dryRun) {
-				if (opts.clean && fsNode.existsSync(outputPath)) fsNode.unlinkSync(outputPath);
-				fsNode.mkdirSync(outputDir, { recursive: true });
-				fsNode.writeFileSync(outputPath, `${JSON.stringify(vendorManifest, null, indent)}\n`);
+				if (opts.clean && fs.existsSync(outputPath)) fs.unlinkSync(outputPath);
+				fs.mkdirSync(outputDir, { recursive: true });
+				fs.writeFileSync(outputPath, `${JSON.stringify(vendorManifest, null, indent)}\n`);
 			}
 			written.push(outputPath);
-			writeSkillArtifacts(root, vendor, skills, opts, written, warnings);
+			if (hooks?.changed) {
+				if (hooks.hooks) writeArtifact(derivedHooksPath, `${JSON.stringify(hooks.hooks, null, indent)}\n`, opts, written);
+				else if (!opts.dryRun && fs.existsSync(derivedHooksPath)) fs.unlinkSync(derivedHooksPath);
+			}
+			writeSkillArtifacts(vendor, skills, opts, written, warnings);
 			rows.push({
 				vendor,
 				path: relPath,
@@ -317,15 +1055,76 @@ function buildPlugin(root, opts = {}) {
 			});
 		}
 	}
+	const catalogs = refreshCatalogs(root, manifest, vendors, opts, written, warnings);
 	return {
 		vendors,
 		written,
 		warnings,
 		rows,
+		catalogs,
 		summary: summarize(rows)
 	};
 }
-function writeSkillArtifacts(root, vendor, skills, opts, written, warnings) {
+/** Keeps the repository's marketplace catalogs true to the manifest just built. A catalog entry's
+*  version is copied from the canonical manifest and never authored (ADR-0010 §3), so the build that
+*  moves the manifest is what re-derives it — otherwise the entry keeps whatever version it was
+*  written with while the plugin moves on.
+*
+*  Only a catalog the repository already carries is touched, and only this plugin's entry inside it.
+*  Creating one is a choice `plugin init --vendor` and `marketplace init` own; a build makes no new
+*  files at the repository root. */
+function refreshCatalogs(root, manifest, vendors, opts, written, warnings) {
+	const repo = gatherCatalogRepo(root);
+	if (!repo) return [];
+	const source = repo.pluginPath === "" ? "./" : `./${repo.pluginPath}`;
+	const plugin = {
+		name: manifest.name,
+		source,
+		metadata: manifest
+	};
+	const rows = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const vendor of vendors) {
+		const target = VENDOR_TARGETS[vendor];
+		if (!target) continue;
+		const relative = TARGET_CATALOG_PATHS[target];
+		if (seen.has(relative)) continue;
+		seen.add(relative);
+		const existing = repo.catalogs[relative];
+		if (existing === void 0) continue;
+		try {
+			const artifact = refreshCatalogEntry(target, plugin, existing);
+			const issues = validateCatalogContent(target, artifact.content);
+			if (issues.length > 0) warnings.push(formatCatalogIssues(relative, issues));
+			if (sameCatalogContent(artifact.content, existing)) {
+				rows.push({
+					path: relative,
+					status: "unchanged"
+				});
+				continue;
+			}
+			if (opts.dryRun) {
+				rows.push({
+					path: relative,
+					status: "planned"
+				});
+				continue;
+			}
+			const file = path.join(repo.root, relative);
+			const content = `${JSON.stringify(JSON.parse(artifact.content), null, detectIndent(existing))}\n`;
+			fs.writeFileSync(file, content);
+			written.push(file);
+			rows.push({
+				path: relative,
+				status: "updated"
+			});
+		} catch (err) {
+			warnings.push(`Failed to refresh "${relative}": ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	return rows;
+}
+function writeSkillArtifacts(vendor, skills, opts, written, warnings) {
 	for (const skill of skills) {
 		if (vendor === "claude-code") {
 			writeClaudeSkill(skill, opts, written);
@@ -344,18 +1143,18 @@ function readSkills(root, manifest) {
 	const skillsCfg = universalPluginExtension(manifest).skills;
 	const skillsPath = typeof skillsCfg === "string" ? skillsCfg : "./skills/";
 	const skillsDir = path.resolve(root, skillsPath);
-	if (!fsNode.existsSync(skillsDir)) return [];
+	if (!fs.existsSync(skillsDir)) return [];
 	return listSkillFiles(skillsDir).map((skillPath) => parseSkill(skillPath));
 }
 function listSkillFiles(dir) {
-	return fsNode.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+	return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
 		const entryPath = path.join(dir, entry.name);
 		if (entry.isDirectory()) return listSkillFiles(entryPath);
 		return entry.isFile() && entry.name === "SKILL.md" ? [entryPath] : [];
 	});
 }
 function parseSkill(skillPath) {
-	const content = fsNode.readFileSync(skillPath, "utf8");
+	const content = fs.readFileSync(skillPath, "utf8");
 	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
 	const frontmatter = match?.[1] ?? "";
 	const rawPolicy = frontmatter.match(/^invocation-policy:\s*['"]?(user|model|both)['"]?\s*(?:#.*)?$/m)?.[1];
@@ -374,7 +1173,7 @@ function writeClaudeSkill(skill, opts, written) {
 	if (!skill.hasInvocationPolicy) return;
 	const content = withClaudeInvocationFlags(skill);
 	if (content === skill.content) return;
-	if (!opts.dryRun) fsNode.writeFileSync(skill.path, content);
+	if (!opts.dryRun) fs.writeFileSync(skill.path, content);
 	written.push(skill.path);
 }
 function withClaudeInvocationFlags(skill) {
@@ -387,9 +1186,9 @@ function withClaudeInvocationFlags(skill) {
 }
 function writeArtifact(outputPath, content, opts, written) {
 	if (!opts.dryRun) {
-		if (opts.clean && fsNode.existsSync(outputPath)) fsNode.unlinkSync(outputPath);
-		fsNode.mkdirSync(path.dirname(outputPath), { recursive: true });
-		fsNode.writeFileSync(outputPath, content);
+		if (opts.clean && fs.existsSync(outputPath)) fs.unlinkSync(outputPath);
+		fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+		fs.writeFileSync(outputPath, content);
 	}
 	written.push(outputPath);
 }
@@ -401,8 +1200,46 @@ function summarize(rows) {
 		canonical: rows.filter((r) => r.status === "canonical").length
 	};
 }
-//#endregion
-//#region src/build/cli.ts
+/** Resolves the canonical hooks declaration — a path, a list of paths, or an inline block — into one
+*  hooks document. Returns null when there is nothing to translate; an unreadable declaration warns
+*  and leaves the declaration to pass through untouched. */
+function readCanonicalHooks(root, declaration, warnings) {
+	if (declaration && typeof declaration === "object" && "hooks" in declaration) return declaration;
+	const paths = (typeof declaration === "string" ? [declaration] : declaration && typeof declaration === "object" && Array.isArray(declaration.paths) ? declaration.paths ?? [] : null) ?? (fs.existsSync(path.resolve(root, DEFAULT_HOOKS_PATH)) ? [DEFAULT_HOOKS_PATH] : []);
+	if (paths.length === 0) return null;
+	const merged = { hooks: {} };
+	let read = 0;
+	for (const relPath of paths) {
+		const hooksPath = path.resolve(root, relPath);
+		if (!fs.existsSync(hooksPath)) {
+			warnings.push(`hooks file "${relPath}" not found — left untranslated`);
+			continue;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(fs.readFileSync(hooksPath, "utf8"));
+		} catch (err) {
+			warnings.push(`hooks file "${relPath}" could not be read — left untranslated: ${err instanceof Error ? err.message : String(err)}`);
+			continue;
+		}
+		read++;
+		for (const [event, rules] of Object.entries(parsed.hooks ?? {})) merged.hooks[event] = [...merged.hooks[event] ?? [], ...rules];
+	}
+	return read === 0 ? null : merged;
+}
+/** One warning per event and handler type — three dropped prompt handlers on one event are one loss
+*  to fix, not three. */
+function dedupeDrops(drops) {
+	const seen = /* @__PURE__ */ new Set();
+	return drops.filter((drop) => {
+		const key = `${drop.event}\u0000${drop.type}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+//#endregion
+//#region src/build/cli.ts
 const NEXT_STEP$2 = "→ universal-plugin plugin validate\n";
 function buildCommand() {
 	const cmd = new Command("build").description("Generate vendor manifests from plugin.json");
@@ -421,17 +1258,23 @@ function buildCommand() {
 				skipped: result.rows.filter((r) => r.status === "skipped"),
 				failed: result.rows.filter((r) => r.status === "failed"),
 				canonical: result.rows.filter((r) => r.status === "canonical"),
+				catalogs: result.catalogs,
 				summary: result.summary,
 				warnings: result.warnings
 			};
 			const counts = `built ${built}, skipped ${skipped}, failed ${failed}`;
+			const catalogSummary = result.catalogs.length > 0 ? `, catalogs ${result.catalogs.length}` : "";
 			output(jsonResult, {
 				vendors: result.rows.map((r) => ({
 					vendor: r.vendor,
 					path: r.path,
 					status: r.status
 				})),
-				summary: canonical > 0 ? `${counts}, served by plugin.json ${canonical}` : counts
+				catalogs: result.catalogs.map((r) => ({
+					path: r.path,
+					status: r.status
+				})),
+				summary: (canonical > 0 ? `${counts}, served by plugin.json ${canonical}` : counts) + catalogSummary
 			});
 			process.stderr.write(NEXT_STEP$2);
 			if (failed > 0) process.exitCode = 1;
@@ -459,9 +1302,9 @@ function resolveSkillsDir(root, manifestSkills) {
 	return path.join(root, manifestSkills ?? "skills/");
 }
 function walk(dir) {
-	if (!fsNode.existsSync(dir)) return [];
+	if (!fs.existsSync(dir)) return [];
 	const files = [];
-	for (const entry of fsNode.readdirSync(dir, { withFileTypes: true })) {
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
 		const entryPath = path.join(dir, entry.name);
 		if (entry.isDirectory()) files.push(...walk(entryPath));
 		else if (entry.isFile() && TEXT_EXTENSIONS.has(path.extname(entry.name))) files.push(entryPath);
@@ -471,8 +1314,8 @@ function walk(dir) {
 function realPinFs(skillsDir) {
 	return {
 		listSkillFiles: () => walk(skillsDir),
-		readFile: (p) => fsNode.readFileSync(p, "utf8"),
-		writeFile: (p, c) => fsNode.writeFileSync(p, c, "utf8")
+		readFile: (p) => fs.readFileSync(p, "utf8"),
+		writeFile: (p, c) => fs.writeFileSync(p, c, "utf8")
 	};
 }
 //#endregion
@@ -606,7 +1449,7 @@ const DEFAULT_GLOBS = ["packages/*"];
 function findMonorepoRoot(start) {
 	let dir = start;
 	for (;;) {
-		if (fsNode.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return dir;
+		if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return dir;
 		const parent = path.dirname(dir);
 		if (parent === dir) return start;
 		dir = parent;
@@ -635,9 +1478,9 @@ function parseWorkspaceGlobs(yamlText) {
 }
 function readWorkspaceGlobs(monorepoRoot) {
 	const yamlPath = path.join(monorepoRoot, "pnpm-workspace.yaml");
-	if (!fsNode.existsSync(yamlPath)) return DEFAULT_GLOBS;
+	if (!fs.existsSync(yamlPath)) return DEFAULT_GLOBS;
 	try {
-		const globs = parseWorkspaceGlobs(fsNode.readFileSync(yamlPath, "utf8"));
+		const globs = parseWorkspaceGlobs(fs.readFileSync(yamlPath, "utf8"));
 		return globs.length > 0 ? globs : DEFAULT_GLOBS;
 	} catch {
 		return DEFAULT_GLOBS;
@@ -648,11 +1491,11 @@ function readWorkspaceGlobs(monorepoRoot) {
 function expandGlob(monorepoRoot, glob) {
 	if (glob.endsWith("/*")) {
 		const base = path.join(monorepoRoot, glob.slice(0, -2));
-		if (!fsNode.existsSync(base)) return [];
-		return fsNode.readdirSync(base, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(base, entry.name));
+		if (!fs.existsSync(base)) return [];
+		return fs.readdirSync(base, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(base, entry.name));
 	}
 	const dir = path.join(monorepoRoot, glob);
-	return fsNode.existsSync(dir) ? [dir] : [];
+	return fs.existsSync(dir) ? [dir] : [];
 }
 /** Discovers every workspace member's version, keyed by its `package.json` `name` field (falling
 *  back to the directory name when `package.json` is missing or unreadable — registering the
@@ -666,7 +1509,7 @@ function discoverWorkspace(root) {
 		let name = path.basename(dir);
 		let version;
 		try {
-			const pkg = JSON.parse(fsNode.readFileSync(path.join(dir, "package.json"), "utf8"));
+			const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
 			if (typeof pkg.name === "string") name = pkg.name;
 			if (typeof pkg.version === "string") version = pkg.version;
 		} catch {}
@@ -684,11 +1527,11 @@ function writePinsMap(root, pins) {
 	const sorted = {};
 	for (const key of Object.keys(map).sort((a, b) => a.localeCompare(b))) sorted[key] = map[key];
 	const dir = path.join(root, ".plugin");
-	fsNode.mkdirSync(dir, { recursive: true });
+	fs.mkdirSync(dir, { recursive: true });
 	const pinsPath = path.join(dir, "pins.json");
-	const existing = fsNode.existsSync(pinsPath) ? fsNode.readFileSync(pinsPath, "utf8") : null;
+	const existing = fs.existsSync(pinsPath) ? fs.readFileSync(pinsPath, "utf8") : null;
 	const indent = existing ? detectIndent(existing) : "	";
-	fsNode.writeFileSync(pinsPath, `${JSON.stringify(sorted, null, indent)}\n`);
+	fs.writeFileSync(pinsPath, `${JSON.stringify(sorted, null, indent)}\n`);
 }
 function realVersionSource(workspace) {
 	return { resolve(pkg) {
@@ -797,14 +1640,14 @@ function configPath(root) {
 const realConfigFs = {
 	read(root) {
 		const file = configPath(root);
-		if (!fsNode.existsSync(file)) return {};
-		return JSON.parse(fsNode.readFileSync(file, "utf8"));
+		if (!fs.existsSync(file)) return {};
+		return JSON.parse(fs.readFileSync(file, "utf8"));
 	},
 	write(root, config) {
 		const file = configPath(root);
-		const indent = fsNode.existsSync(file) ? detectIndent(fsNode.readFileSync(file, "utf8")) : "	";
-		fsNode.mkdirSync(path.dirname(file), { recursive: true });
-		fsNode.writeFileSync(file, `${JSON.stringify(config, null, indent)}\n`);
+		const indent = fs.existsSync(file) ? detectIndent(fs.readFileSync(file, "utf8")) : "	";
+		fs.mkdirSync(path.dirname(file), { recursive: true });
+		fs.writeFileSync(file, `${JSON.stringify(config, null, indent)}\n`);
 	}
 };
 //#endregion
@@ -866,11 +1709,11 @@ function configCommand(fs = realConfigFs) {
 //#endregion
 //#region src/governance/fs.ts
 const realGovernanceFs = {
-	exists: (p) => fsNode.existsSync(p),
-	read: (p) => fsNode.readFileSync(p, "utf8"),
+	exists: (p) => fs.existsSync(p),
+	read: (p) => fs.readFileSync(p, "utf8"),
 	list: (dir) => {
-		if (!fsNode.existsSync(dir)) return [];
-		return fsNode.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3));
+		if (!fs.existsSync(dir)) return [];
+		return fs.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3));
 	}
 };
 //#endregion
@@ -973,7 +1816,7 @@ function listGovernances(root, govFs) {
 function readGlobalState() {
 	const p = path.join(os.homedir(), ".agents", "universal-plugin.json");
 	try {
-		return mergeSafeState(JSON.parse(fsNode.readFileSync(p, "utf8")));
+		return mergeSafeState(JSON.parse(fs.readFileSync(p, "utf8")));
 	} catch {
 		return emptyState();
 	}
@@ -1007,6 +1850,45 @@ function governanceCommand() {
 }
 //#endregion
 //#region src/init/fs.ts
+function git(root, args) {
+	try {
+		return execFileSync("git", [
+			"-C",
+			root,
+			...args
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+/** Where the plugin sits in its repository, and the catalogs that repository already carries.
+*  `undefined` outside a repository, which is the one case with nowhere to put a catalog. The
+*  repository-and-catalogs half is shared with `plugin build`, which refreshes the same files. */
+function gatherRepo(root) {
+	const repo = gatherCatalogRepo(root);
+	if (!repo) return void 0;
+	const match = git(root, [
+		"remote",
+		"get-url",
+		"origin"
+	])?.match(/[/:]([^/:]+)\/([^/]+?)(?:\.git)?$/);
+	return {
+		pluginPath: repo.pluginPath,
+		dirName: path.basename(repo.root),
+		slug: match ? {
+			owner: match[1],
+			repo: match[2]
+		} : void 0,
+		catalogs: repo.catalogs
+	};
+}
 function manifestPath(root) {
 	return path.join(root, "plugin.json");
 }
@@ -1016,26 +1898,32 @@ function packageJsonPath(root) {
 const realInitFs = {
 	gather(root) {
 		const pj = packageJsonPath(root);
-		const packageJson = fsNode.existsSync(pj) ? JSON.parse(fsNode.readFileSync(pj, "utf8")) : null;
+		const packageJson = fs.existsSync(pj) ? JSON.parse(fs.readFileSync(pj, "utf8")) : null;
 		return {
-			manifestExists: fsNode.existsSync(manifestPath(root)),
-			packageJson
+			manifestExists: fs.existsSync(manifestPath(root)),
+			packageJson,
+			repo: gatherRepo(root)
 		};
 	},
 	apply(root, plan) {
-		fsNode.writeFileSync(manifestPath(root), `${JSON.stringify(plan.manifest, null, "	")}\n`);
-		for (const dir of plan.dirs) fsNode.mkdirSync(path.join(root, dir), { recursive: true });
+		fs.writeFileSync(manifestPath(root), `${JSON.stringify(plan.manifest, null, "	")}\n`);
+		for (const dir of plan.dirs) fs.mkdirSync(path.join(root, dir), { recursive: true });
+		for (const catalog of plan.catalogs) {
+			const file = path.join(root, catalog.path);
+			fs.mkdirSync(path.dirname(file), { recursive: true });
+			fs.writeFileSync(file, catalog.content);
+		}
 		if (plan.packageJson) {
 			const pj = packageJsonPath(root);
-			const indent = detectIndent(fsNode.readFileSync(pj, "utf8"));
-			fsNode.writeFileSync(pj, `${JSON.stringify(plan.packageJson, null, indent)}\n`);
+			const indent = detectIndent(fs.readFileSync(pj, "utf8"));
+			fs.writeFileSync(pj, `${JSON.stringify(plan.packageJson, null, indent)}\n`);
 		}
 	}
 };
 //#endregion
 //#region src/init/init.ts
-/** Pure domain for `plugin init` — scaffolding the canonical manifest and (with `--npm`)
-*  wiring an npm package to ship it.
+/** Pure domain for `plugin init` — scaffolding the canonical manifest, registering the plugin in the
+*  repository's local marketplace catalogs, and (with `--npm`) wiring an npm package to ship it.
 *
 *  No I/O: the caller gathers the current filesystem state, calls `planInit`, and applies the
 *  returned plan. `planInit` owns the rules — the guard order, the closed manifest shape, the
@@ -1077,6 +1965,73 @@ function wireFiles(pkg, manifestPaths) {
 		files
 	};
 }
+/** The local marketplace a repository carries is named after the repository, not after the plugin:
+*  the catalog sits at the repository root and lists every plugin the repository develops. `-local`
+*  separates it from a published marketplace of the same plugins. */
+function marketplaceName(repo) {
+	return `${repo.slug ? `${repo.slug.owner}-${repo.slug.repo}` : repo.dirName}-local`;
+}
+/** An npm `author` — `"Bea <bea@example.com> (https://example.com)"` or the object form — read as a
+*  catalog owner. */
+function readAuthor(author) {
+	if (typeof author === "string") {
+		const name = author.replace(/[<(].*$/, "").trim();
+		return name === "" ? void 0 : { name };
+	}
+	if (typeof author !== "object" || author === null) return void 0;
+	const record = author;
+	if (typeof record.name !== "string" || record.name.trim() === "") return void 0;
+	const owner = { name: record.name };
+	if (typeof record.email === "string") owner.email = record.email;
+	if (typeof record.url === "string") owner.url = record.url;
+	return owner;
+}
+/** Who the catalog says maintains the marketplace. The canonical manifest first, then the package
+*  that ships it, then the account the repository lives under. Every runtime requires this, so a
+*  repository with none of the three gets no catalog rather than an invented owner. */
+function catalogOwner(state, repo, manifest) {
+	return readAuthor(manifest.author) ?? readAuthor(state.packageJson?.author) ?? (repo.slug ? { name: repo.slug.owner } : void 0);
+}
+/** The plugin's own entry in every selected vendor's catalog, folded into whatever the repository
+*  already carries. Nothing here authors a version: the entry carries the canonical manifest's, and
+*  the manifest `init` writes carries none (ADR-0010). */
+function planCatalogs(state, opts, manifest, notes) {
+	if (opts.marketplace === false || opts.vendors.length === 0) return [];
+	const repo = state.repo;
+	if (!repo) {
+		notes.push("no local marketplace catalog: the plugin root is not inside a repository");
+		return [];
+	}
+	const owner = catalogOwner(state, repo, manifest);
+	if (!owner) {
+		notes.push("no local marketplace catalog: no owner to name — add an author to plugin.json");
+		return [];
+	}
+	const metadata = {
+		name: marketplaceName(repo),
+		owner
+	};
+	const source = repo.pluginPath === "" ? "./" : `./${repo.pluginPath}`;
+	const plugin = {
+		name: manifest.name,
+		source,
+		metadata: manifest
+	};
+	const toPluginRoot = repo.pluginPath === "" ? "" : `${repo.pluginPath.split("/").map(() => "..").join("/")}/`;
+	const catalogs = [];
+	for (const vendor of opts.vendors) {
+		const target = VENDOR_TARGETS[vendor];
+		if (!target) continue;
+		const artifact = mergeCatalogEntry(target, metadata, plugin, (path) => repo.catalogs[path]);
+		const issues = validateCatalogContent(target, artifact.content);
+		if (issues.length > 0) notes.push(formatCatalogIssues(artifact.path, issues));
+		catalogs.push({
+			path: `${toPluginRoot}${artifact.path}`,
+			content: artifact.content
+		});
+	}
+	return catalogs;
+}
 /** Plans the init run. Throws on a guard failure (an existing manifest without `--force`; `--npm`
 *  with no `package.json`) before returning any plan, so the caller writes nothing on a guard trip. */
 function planInit(state, opts, rootDirName, resolveManifestPath) {
@@ -1088,6 +2043,16 @@ function planInit(state, opts, rootDirName, resolveManifestPath) {
 		path: "plugin.json",
 		action: "created"
 	}];
+	const notes = [];
+	const catalogs = planCatalogs(state, opts, manifest, notes);
+	const existing = state.repo?.catalogs ?? {};
+	for (const catalog of catalogs) {
+		const previous = existing[catalog.path.replace(/^(\.\.\/)+/, "")];
+		rows.push({
+			path: catalog.path,
+			action: previous === void 0 ? "created" : previous === catalog.content ? "unchanged" : "updated"
+		});
+	}
 	let packageJson = null;
 	if (opts.npm) {
 		const manifestPaths = (opts.vendors.length > 0 ? opts.vendors : ["claude-code"]).map(resolveManifestPath).filter((p) => Boolean(p));
@@ -1099,26 +2064,30 @@ function planInit(state, opts, rootDirName, resolveManifestPath) {
 	}
 	const created = rows.filter((r) => r.action === "created").length;
 	const updated = rows.filter((r) => r.action === "updated").length;
+	const unchanged = rows.filter((r) => r.action === "unchanged").length;
 	return {
 		manifest,
 		dirs,
 		packageJson,
+		catalogs,
 		rows,
+		notes,
 		summary: {
 			created,
-			updated
+			updated,
+			unchanged
 		}
 	};
 }
 //#endregion
 //#region src/init/cli.ts
 const NEXT_STEP = "→ add skills to skills/, then run universal-plugin plugin build\n";
-function collect(value, previous) {
+function collect$1(value, previous) {
 	return [...previous, value];
 }
 function initCommand$1(deps = { fs: realInitFs }) {
 	const cmd = new Command("init").description("Scaffold the canonical plugin.json (with --npm, wire an npm package to ship it)");
-	cmd.option("--name <name>", "Plugin name (default: the root directory name)").option("--vendor <id>", "Target vendor; repeatable", collect, []).option("--scaffold", "Create the standard skills/ agents/ governances/ commands/ directories").option("--force", "Overwrite an existing plugin.json").option("--yes", "Non-interactive (compatibility no-op; init never prompts)").option("--npm", "Wire package.json 'files' to ship the derived vendor manifests").option("--format <format>", "Output format: json or toon (default: toon)").addOption(new Option("--json").hideHelp()).addOption(ROOT_OPTION).addHelpText("after", "\nExample:\n  $ universal-plugin plugin init --name my-plugin --scaffold\n").action((opts) => {
+	cmd.option("--name <name>", "Plugin name (default: the root directory name)").option("--vendor <id>", "Target vendor; repeatable", collect$1, []).option("--scaffold", "Create the standard skills/ agents/ governances/ commands/ directories").option("--force", "Overwrite an existing plugin.json").option("--yes", "Non-interactive (compatibility no-op; init never prompts)").option("--npm", "Wire package.json 'files' to ship the derived vendor manifests").option("--no-marketplace", "Skip the repository's local marketplace catalogs").option("--format <format>", "Output format: json or toon (default: toon)").addOption(new Option("--json").hideHelp()).addOption(ROOT_OPTION).addHelpText("after", "\nExample:\n  $ universal-plugin plugin init --name my-plugin --scaffold\n").action((opts) => {
 		try {
 			const root = resolveRoot(opts.root);
 			const plan = planInit(deps.fs.gather(root), {
@@ -1126,7 +2095,8 @@ function initCommand$1(deps = { fs: realInitFs }) {
 				vendors: opts.vendor ?? [],
 				scaffold: Boolean(opts.scaffold),
 				force: Boolean(opts.force),
-				npm: Boolean(opts.npm)
+				npm: Boolean(opts.npm),
+				marketplace: opts.marketplace !== false
 			}, path.basename(root), (vendor) => VENDOR_OUTPUT[vendor]);
 			deps.fs.apply(root, plan);
 			output({
@@ -1138,8 +2108,9 @@ function initCommand$1(deps = { fs: realInitFs }) {
 					path: r.path,
 					action: r.action
 				})),
-				summary: `created ${plan.summary.created}, updated ${plan.summary.updated}`
+				summary: `created ${plan.summary.created}, updated ${plan.summary.updated}, unchanged ${plan.summary.unchanged}`
 			});
+			for (const note of plan.notes) process.stderr.write(`${note}\n`);
 			process.stderr.write(NEXT_STEP);
 		} catch (err) {
 			process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
@@ -1149,123 +2120,380 @@ function initCommand$1(deps = { fs: realInitFs }) {
 	return cmd;
 }
 //#endregion
-//#region src/marketplace/fs.ts
-const realMarketplaceFs = {
-	exists: fsNode.existsSync,
-	isDirectory(file) {
-		return fsNode.statSync(file).isDirectory();
-	},
-	realpath(file) {
-		return fsNode.realpathSync(file);
-	},
-	read(file) {
-		return fsNode.readFileSync(file, "utf8");
-	},
-	listEntries(dir) {
-		return fsNode.readdirSync(dir);
-	},
-	writeAtomically(file, content) {
-		fsNode.mkdirSync(path.dirname(file), { recursive: true });
-		const temporary = `${file}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
-		fsNode.writeFileSync(temporary, content);
-		fsNode.renameSync(temporary, file);
+//#region src/vendor-registry/vendor-registry.ts
+function lookupVendor(registry, vendorId) {
+	return registry[vendorId] ?? null;
+}
+function mergeRegistries(base, override) {
+	const result = { ...base };
+	for (const [id, config] of Object.entries(override)) result[id] = {
+		...base[id] ?? {},
+		...config
+	};
+	return result;
+}
+//#endregion
+//#region src/vendor-registry/fs.ts
+function bundledRegistryPath() {
+	const thisFile = fileURLToPath(import.meta.url);
+	return path.join(path.dirname(thisFile), "data", "vendors.json");
+}
+function userOverridePath() {
+	return path.join(os.homedir(), ".agents", "universal-plugin-vendors.json");
+}
+function loadRegistry() {
+	const bundled = JSON.parse(fs.readFileSync(bundledRegistryPath(), "utf8"));
+	try {
+		return mergeRegistries(bundled, JSON.parse(fs.readFileSync(userOverridePath(), "utf8")));
+	} catch (err) {
+		if (err.code === "ENOENT") return bundled;
+		throw err;
 	}
-};
+}
 //#endregion
-//#region src/marketplace/marketplace.ts
-const COMMON_METADATA = [
-	"description",
-	"version",
-	"homepage",
-	"repository",
-	"license",
-	"keywords"
-];
-function assertMarketplaceName(value, label) {
-	if (!/^[a-z0-9][a-z0-9._-]*$/i.test(value)) throw new Error(`error: ${label} "${value}" must contain only letters, digits, dots, underscores, or hyphens`);
+//#region src/install/fs.ts
+function expandHome$1(p) {
+	return p.startsWith("~") ? path.join(os.homedir(), p.slice(1)) : p;
 }
-function commonMetadata(plugin) {
-	const result = {};
-	for (const field of COMMON_METADATA) if (plugin.metadata[field] !== void 0) result[field] = plugin.metadata[field];
-	return result;
+/** Resolves a vendor's local plugin directory to an absolute path. */
+function resolveLocalDir(localPluginDir) {
+	return localPluginDir === null ? null : path.resolve(expandHome$1(localPluginDir));
 }
-function json(value) {
-	return `${JSON.stringify(value, null, 2)}\n`;
+/** Reads what occupies a destination. A symlink is reported with its resolved target so the plan
+*  can tell our own install from someone else's; a directory is reported with the `name` of the
+*  canonical manifest inside it, which is what identifies an earlier `--copy` install. */
+function readDestination(dest) {
+	let stats;
+	try {
+		stats = fs.lstatSync(dest);
+	} catch (err) {
+		if (err.code === "ENOENT") return { kind: "absent" };
+		throw err;
+	}
+	if (stats.isSymbolicLink()) try {
+		return {
+			kind: "symlink",
+			target: fs.realpathSync(dest)
+		};
+	} catch {
+		return {
+			kind: "symlink",
+			target: fs.readlinkSync(dest)
+		};
+	}
+	if (!stats.isDirectory()) return { kind: "file" };
+	return {
+		kind: "directory",
+		pluginName: readPluginName(path.join(dest, "plugin.json"))
+	};
 }
-function claudeArtifact(metadata, plugins) {
+function readPluginName(manifestPath) {
+	try {
+		const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+		return typeof manifest.name === "string" ? manifest.name : null;
+	} catch {
+		return null;
+	}
+}
+/** Entries a copy never carries: the working copy's history and its installed dependencies. Neither
+*  is part of the plugin, and both dwarf it. */
+const COPY_EXCLUDED = new Set([".git", "node_modules"]);
+/** Applies one planned write. A replace removes the destination first, so a copy never merges into
+*  what was there before. A copy dereferences symlinks — a skill linked into the tree has to travel
+*  as its content, since the destination is read on its own. */
+function applyWrite(root, write) {
+	if (write.replace) fs.rmSync(write.dest, {
+		recursive: true,
+		force: true
+	});
+	fs.mkdirSync(path.dirname(write.dest), { recursive: true });
+	if (write.mode === "link") {
+		fs.symlinkSync(root, write.dest, "dir");
+		return;
+	}
+	fs.cpSync(root, write.dest, {
+		recursive: true,
+		dereference: true,
+		filter: (source) => !COPY_EXCLUDED.has(path.basename(source))
+	});
+}
+function applyRemoval(dest) {
+	fs.rmSync(dest, {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/install/install.ts
+/** Pure domain for `plugin install` / `plugin uninstall` — putting the plugin under development
+*  into a runtime, and taking it back out.
+*
+*  No I/O: the caller resolves each vendor's local plugin directory, reads what currently occupies
+*  the destination, and applies the returned plan. The rules live here — how a mode resolves per
+*  vendor, what counts as our own install, and when a destination is refused. */
+/** The destination this plugin occupies in a vendor's local plugin directory. */
+function destinationPath(dir, pluginName) {
+	return path.join(dir, pluginName);
+}
+/** Whether a destination holds this plugin already — our symlink back to the root, or a directory
+*  carrying this plugin's canonical manifest. Anything else belongs to someone else. */
+function isOurs(state, root, pluginName) {
+	if (state.kind === "symlink") return state.target === root;
+	if (state.kind === "directory") return state.pluginName === pluginName;
+	return false;
+}
+function occupiedReason(state) {
+	if (state.kind === "symlink") return `a symlink to ${state.target} is already there; --force replaces it`;
+	if (state.kind === "directory") return "another plugin is already installed there; --force replaces it";
+	return "a file is already there; --force replaces it";
+}
+/** The mode a vendor actually gets. Returns `null` when `--link` was demanded of a vendor that
+*  rejects an out-of-tree symlink — the caller reports that as blocked rather than silently
+*  copying, since the author asked for a live link and would not get one. */
+function resolveMode$1(mode, target) {
+	if (mode === "copy") return "copy";
+	if (target.link) return "link";
+	return mode === "link" ? null : "copy";
+}
+/** Plans an install. Throws when a targeted vendor's derived manifest is missing — installing a
+*  plugin whose manifests were never built hands the runtime a half-built plugin, and the author
+*  finds out as a load failure rather than as an error here. */
+function planInstall(input) {
+	const missing = input.targets.filter((t) => t.dir !== null && input.manifests[t.vendor] === false);
+	if (missing.length > 0) {
+		const paths = missing.map((t) => `  - ${t.manifestPath} (${t.vendor})`).join("\n");
+		throw new Error(`No derived manifest for:\n${paths}\nRun universal-plugin plugin build first.`);
+	}
+	const rows = [];
+	const writes = [];
+	for (const target of input.targets) {
+		if (target.dir === null) {
+			rows.push({
+				vendor: target.vendor,
+				path: "-",
+				action: "unsupported",
+				reason: `${target.vendor} has no local plugin directory; install it from a repository-local marketplace instead`
+			});
+			continue;
+		}
+		const dest = destinationPath(target.dir, input.pluginName);
+		const state = input.dest[target.vendor] ?? { kind: "absent" };
+		const mode = resolveMode$1(input.mode, target);
+		if (mode === null) {
+			rows.push({
+				vendor: target.vendor,
+				path: dest,
+				action: "blocked",
+				reason: `${target.vendor} does not load a symlink from outside ${target.dir}; use --copy`
+			});
+			continue;
+		}
+		const ours = isOurs(state, input.root, input.pluginName);
+		if (state.kind !== "absent" && !ours && !input.force) {
+			rows.push({
+				vendor: target.vendor,
+				path: dest,
+				action: "blocked",
+				reason: occupiedReason(state)
+			});
+			continue;
+		}
+		if (ours && mode === "link" && state.kind === "symlink") {
+			rows.push({
+				vendor: target.vendor,
+				path: dest,
+				action: "unchanged"
+			});
+			continue;
+		}
+		writes.push({
+			vendor: target.vendor,
+			dest,
+			mode,
+			replace: state.kind !== "absent"
+		});
+		rows.push({
+			vendor: target.vendor,
+			path: dest,
+			action: mode === "link" ? "linked" : "copied"
+		});
+	}
 	return {
-		path: ".claude-plugin/marketplace.json",
-		content: json({
-			...metadata,
-			plugins: plugins.map((plugin) => ({
-				name: plugin.name,
-				source: plugin.source,
-				...commonMetadata(plugin)
-			}))
-		})
+		rows,
+		writes,
+		summary: summarizeInstall(rows)
 	};
 }
-function codexArtifact(metadata, plugins) {
+/** Plans an uninstall. Never throws: a destination that was never installed is reported, not an
+*  error, so `uninstall` is safe to run twice and safe to run over a partial install. */
+function planUninstall(input) {
+	const rows = [];
+	const removals = [];
+	for (const target of input.targets) {
+		if (target.dir === null) {
+			rows.push({
+				vendor: target.vendor,
+				path: "-",
+				action: "unsupported"
+			});
+			continue;
+		}
+		const dest = destinationPath(target.dir, input.pluginName);
+		const state = input.dest[target.vendor] ?? { kind: "absent" };
+		if (state.kind === "absent") {
+			rows.push({
+				vendor: target.vendor,
+				path: dest,
+				action: "missing"
+			});
+			continue;
+		}
+		if (!isOurs(state, input.root, input.pluginName) && !input.force) {
+			rows.push({
+				vendor: target.vendor,
+				path: dest,
+				action: "blocked",
+				reason: "this is not an install of this plugin; --force removes it anyway"
+			});
+			continue;
+		}
+		removals.push(dest);
+		rows.push({
+			vendor: target.vendor,
+			path: dest,
+			action: "removed"
+		});
+	}
 	return {
-		path: ".agents/plugins/marketplace.json",
-		content: json({
-			name: metadata.name,
-			interface: { displayName: metadata.name },
-			plugins: plugins.map((plugin) => ({
-				name: plugin.name,
-				version: plugin.metadata.version,
-				source: {
-					source: "local",
-					path: plugin.source
-				},
-				policy: {
-					installation: "AVAILABLE",
-					authentication: "ON_INSTALL"
-				},
-				category: "Productivity"
-			}))
-		})
+		rows,
+		removals,
+		summary: summarizeUninstall(rows)
 	};
 }
-function copilotArtifact(metadata, plugins) {
+function summarizeInstall(rows) {
+	const count = (action) => rows.filter((r) => r.action === action).length;
 	return {
-		path: ".github/plugin/marketplace.json",
-		content: json({
-			...metadata,
-			metadata: { displayName: metadata.name },
-			plugins: plugins.map((plugin) => ({
-				name: plugin.name,
-				source: plugin.source,
-				...commonMetadata(plugin)
-			}))
-		})
+		installed: count("linked") + count("copied"),
+		unchanged: count("unchanged"),
+		blocked: count("blocked"),
+		unsupported: count("unsupported")
 	};
 }
-function cursorArtifacts(metadata, plugins) {
-	const sources = plugins.map((plugin) => ({
-		name: plugin.name,
-		source: plugin.source,
-		...commonMetadata(plugin)
-	}));
-	return [{
-		path: ".cursor-plugin/marketplace-submission.json",
-		content: json({
-			...metadata,
-			plugins: sources,
-			dashboard: "https://cursor.com/dashboard"
-		})
-	}, {
-		path: "CURSOR_MARKETPLACE_SUBMISSION.md",
-		content: `# Cursor Marketplace Submission\n\nMarketplace: ${metadata.name}\nOwner: ${metadata.owner}\n\nPlugins:\n${sources.map((plugin) => `- ${plugin.name}: ${plugin.source}`).join("\n")}\n\nSubmit this metadata through the [Cursor dashboard](https://cursor.com/dashboard). This command generated local submission metadata only; no publication or provisioning occurred.\n`
-	}];
+function summarizeUninstall(rows) {
+	const count = (action) => rows.filter((r) => r.action === action).length;
+	return {
+		removed: count("removed"),
+		missing: count("missing"),
+		blocked: count("blocked"),
+		unsupported: count("unsupported")
+	};
 }
-function serializeTarget(target, metadata, plugins) {
-	switch (target) {
-		case "claude": return [claudeArtifact(metadata, plugins)];
-		case "codex": return [codexArtifact(metadata, plugins)];
-		case "copilot": return [copilotArtifact(metadata, plugins)];
-		case "cursor": return cursorArtifacts(metadata, plugins);
+//#endregion
+//#region src/install/cli.ts
+function collect(value, previous) {
+	return [...previous, value];
+}
+function resolveMode(opts) {
+	if (opts.link && opts.copy) throw new Error("--link and --copy are mutually exclusive");
+	if (opts.link) return "link";
+	if (opts.copy) return "copy";
+	return "auto";
+}
+/** Gathers everything the pure planner needs: the plugin's name, the vendors it declares, each
+*  vendor's local-install facts, and what currently sits at each destination. */
+function gather(root, opts, mode) {
+	const manifest = readManifest(root);
+	if (!manifest.name) throw new Error(`plugin.json at ${root} declares no name`);
+	const uext = universalPluginExtension(manifest);
+	const declared = uext.vendors ?? Object.keys(uext.harnesses ?? {});
+	const selected = opts.vendor?.length ? opts.vendor : declared;
+	for (const vendor of selected) if (!declared.includes(vendor)) throw new Error(`Vendor "${vendor}" not declared in this plugin's manifest`);
+	if (selected.length === 0) throw new Error("No vendors declared in this plugin's manifest — nothing to install");
+	const registry = loadRegistry();
+	const targets = selected.map((vendor) => {
+		const config = registry[vendor];
+		if (!config) throw new Error(`Unknown vendor: ${vendor}`);
+		return {
+			vendor,
+			dir: resolveLocalDir(config.localPluginDir),
+			link: config.localPluginLink,
+			manifestPath: VENDOR_OUTPUT[vendor] ?? "plugin.json"
+		};
+	});
+	const dest = {};
+	const manifests = {};
+	for (const target of targets) {
+		manifests[target.vendor] = fs.existsSync(path.join(root, target.manifestPath));
+		if (target.dir !== null) dest[target.vendor] = readDestination(destinationPath(target.dir, manifest.name));
 	}
+	return {
+		pluginName: manifest.name,
+		root,
+		mode,
+		force: Boolean(opts.force),
+		targets,
+		dest,
+		manifests
+	};
+}
+/** The per-vendor step the runtime needs before it sees the change. Printed for every vendor the
+*  run actually touched — an install nothing reloads looks exactly like an install that failed. */
+function reloadNotes(vendors) {
+	const registry = loadRegistry();
+	return vendors.map((vendor) => {
+		const reload = registry[vendor]?.localReload;
+		return reload ? `→ ${vendor}: ${reload}` : null;
+	}).filter((line) => line !== null);
+}
+function installCommand() {
+	const cmd = new Command("install").description("Install this plugin into the runtimes it targets, for local development");
+	cmd.option("--vendor <id>", "Install only the named vendor; repeatable", collect, []).option("--link", "Symlink the plugin root, failing a vendor that will not load one").option("--copy", "Copy the plugin root instead of linking it").option("--force", "Replace a destination this plugin does not own").option("--list", "Print the resolved targets and destinations without writing").option("--format <format>", "Output format: json or toon (default: toon)").addOption(new Option("--json").hideHelp()).addOption(ROOT_OPTION).addHelpText("after", "\nExample:\n  $ universal-plugin plugin install --vendor claude-code\n").action((opts) => {
+		try {
+			const root = resolveRoot(opts.root);
+			const plan = planInstall(gather(root, opts, resolveMode(opts)));
+			if (!opts.list) for (const write of plan.writes) applyWrite(root, write);
+			const { installed, unchanged, blocked, unsupported } = plan.summary;
+			output(plan, {
+				vendors: plan.rows.map((r) => ({
+					vendor: r.vendor,
+					path: r.path,
+					action: r.action
+				})),
+				summary: `installed ${installed}, unchanged ${unchanged}, blocked ${blocked}, unsupported ${unsupported}`
+			});
+			for (const row of plan.rows) if (row.reason) process.stderr.write(`warn: ${row.vendor}: ${row.reason}\n`);
+			if (!opts.list) for (const note of reloadNotes(plan.writes.map((w) => w.vendor))) process.stderr.write(`${note}\n`);
+			if (blocked > 0) process.exitCode = 1;
+		} catch (err) {
+			process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+			process.exit(1);
+		}
+	});
+	return cmd;
+}
+function uninstallCommand() {
+	const cmd = new Command("uninstall").description("Remove this plugin from the runtimes it was installed into");
+	cmd.option("--vendor <id>", "Uninstall only the named vendor; repeatable", collect, []).option("--force", "Remove a destination this plugin does not own").option("--list", "Print what would be removed without removing it").option("--format <format>", "Output format: json or toon (default: toon)").addOption(new Option("--json").hideHelp()).addOption(ROOT_OPTION).addHelpText("after", "\nExample:\n  $ universal-plugin plugin uninstall\n").action((opts) => {
+		try {
+			const plan = planUninstall(gather(resolveRoot(opts.root), opts, "auto"));
+			if (!opts.list) for (const dest of plan.removals) applyRemoval(dest);
+			const { removed, missing, blocked, unsupported } = plan.summary;
+			output(plan, {
+				vendors: plan.rows.map((r) => ({
+					vendor: r.vendor,
+					path: r.path,
+					action: r.action
+				})),
+				summary: `removed ${removed}, missing ${missing}, blocked ${blocked}, unsupported ${unsupported}`
+			});
+			for (const row of plan.rows) if (row.reason) process.stderr.write(`warn: ${row.vendor}: ${row.reason}\n`);
+			if (blocked > 0) process.exitCode = 1;
+		} catch (err) {
+			process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+			process.exit(1);
+		}
+	});
+	return cmd;
 }
 //#endregion
 //#region src/marketplace/init.ts
@@ -1294,11 +2522,17 @@ function parseManifest(fs, file) {
 		throw new Error(`error: manifest "${file}" is not valid JSON`);
 	}
 }
+/** The canonical manifest's `author` — a string or an `{ name, email?, url? }` object — read as the
+*  catalog owner every runtime requires as an object. */
 function manifestOwner(manifest) {
-	if (typeof manifest.author === "string") return manifest.author;
+	if (typeof manifest.author === "string") return { name: manifest.author };
 	if (typeof manifest.author === "object" && manifest.author !== null) {
 		const author = manifest.author;
-		if (typeof author.name === "string") return author.name;
+		if (typeof author.name !== "string") return void 0;
+		const owner = { name: author.name };
+		if (typeof author.email === "string") owner.email = author.email;
+		if (typeof author.url === "string") owner.url = author.url;
+		return owner;
 	}
 }
 function deriveMetadata(root, fs, opts) {
@@ -1306,9 +2540,9 @@ function deriveMetadata(root, fs, opts) {
 	if (fs.exists(rootManifest)) assertContained(root, rootManifest, fs, "root plugin.json");
 	const manifest = fs.exists(rootManifest) ? parseManifest(fs, rootManifest) : {};
 	const name = opts.name ?? path.basename(root);
-	const owner = opts.owner ?? manifestOwner(manifest);
+	const owner = opts.owner !== void 0 ? { name: opts.owner } : manifestOwner(manifest);
 	assertMarketplaceName(name, "marketplace name");
-	if (!owner || owner.trim() === "") throw new Error("error: marketplace owner is required; set --owner or root plugin.json author");
+	if (!owner || owner.name.trim() === "") throw new Error("error: marketplace owner is required; set --owner or root plugin.json author");
 	return {
 		name,
 		owner
@@ -1357,9 +2591,6 @@ function discoverPlugins(root, fs, scanDirs) {
 	}
 	return plugins.sort((a, b) => a.name.localeCompare(b.name));
 }
-function assertCodexPluginVersions(plugins) {
-	for (const plugin of plugins) if (typeof plugin.metadata.version !== "string" || plugin.metadata.version.trim() === "") throw new Error(`error: canonical plugin manifest for Codex entry "${plugin.name}" requires a version`);
-}
 function writeArtifacts(fs, artifacts, root) {
 	const changed = artifacts.filter((artifact) => !sameArtifact(fs, path.join(root, artifact.path), artifact.content));
 	for (const artifact of changed) fs.writeAtomically(path.join(root, artifact.path), artifact.content);
@@ -1368,7 +2599,8 @@ function selectedTargets(targets) {
 	return targets && targets.length > 0 ? [...new Set(targets)] : [
 		"claude",
 		"codex",
-		"copilot"
+		"copilot",
+		"cursor"
 	];
 }
 function sameArtifact(fs, file, content) {
@@ -1392,13 +2624,15 @@ function initializeMarketplace(rootInput, opts = {}, fs = realMarketplaceFs) {
 	const root = path.resolve(rootInput);
 	const metadata = deriveMetadata(root, fs, opts);
 	const plugins = discoverPlugins(root, fs, opts.scanDirs);
-	const targets = selectedTargets(opts.targets);
-	if (targets.includes("codex")) assertCodexPluginVersions(plugins);
-	const planned = targets.map((target) => ({
+	const planned = selectedTargets(opts.targets).map((target) => ({
 		target,
 		artifacts: serializeTarget(target, metadata, plugins)
 	}));
-	for (const { artifacts } of planned) for (const artifact of artifacts) assertContained(root, path.join(root, artifact.path), fs, "selected artifact");
+	for (const { target, artifacts } of planned) for (const artifact of artifacts) {
+		assertContained(root, path.join(root, artifact.path), fs, "selected artifact");
+		const issues = validateCatalogContent(target, artifact.content);
+		if (issues.length > 0) throw new Error(formatCatalogIssues(artifact.path, issues));
+	}
 	const conflicts = [];
 	for (const entry of planned) for (const artifact of entry.artifacts) {
 		const output = path.join(root, artifact.path);
@@ -1422,16 +2656,69 @@ function initializeMarketplace(rootInput, opts = {}, fs = realMarketplaceFs) {
 		};
 	});
 	if (!opts.dryRun && plugins.length > 0) writeArtifacts(fs, planned.flatMap((entry) => entry.artifacts), root);
-	if (!opts.targets || opts.targets.length === 0) results.push({
-		target: "cursor",
-		status: "skipped-default",
-		paths: [],
-		plugins: [],
-		reason: "Cursor requires an explicit submission scaffold"
-	});
 	return results;
 }
 //#endregion
+//#region src/marketplace/validate.ts
+/** A `./`-prefixed source names a directory inside the repository, and Claude Code resolves it
+*  against the directory holding `.claude-plugin/`. A source pointing nowhere passes every schema
+*  check and still installs nothing, so the on-disk check belongs here rather than in the rules. */
+function checkSources(root, fs, catalog) {
+	if (typeof catalog !== "object" || catalog === null) return [];
+	const plugins = catalog.plugins;
+	if (!Array.isArray(plugins)) return [];
+	const issues = [];
+	plugins.forEach((entry, index) => {
+		if (typeof entry !== "object" || entry === null) return;
+		const source = entry.source;
+		const location = typeof source === "string" ? source : typeof source === "object" && source !== null ? source.path : void 0;
+		if (typeof location !== "string" || !location.startsWith("./")) return;
+		if (!fs.exists(path.join(root, location))) issues.push({
+			path: `plugins[${index}].source`,
+			message: `points at "${location}", which does not exist`
+		});
+	});
+	return issues;
+}
+/** Checks the catalogs a repository carries against the shape each runtime loads. Reads only; it
+*  repairs nothing, because a catalog someone hand-edited is theirs to correct. */
+function validateMarketplace(rootInput, opts = {}, fs = realMarketplaceFs) {
+	const root = path.resolve(rootInput);
+	return (opts.targets && opts.targets.length > 0 ? [...new Set(opts.targets)] : [
+		"claude",
+		"codex",
+		"copilot",
+		"cursor"
+	]).map((target) => {
+		const relative = TARGET_CATALOG_PATHS[target];
+		const file = path.join(root, relative);
+		if (!fs.exists(file)) return {
+			target,
+			path: relative,
+			status: opts.required ? "invalid" : "missing",
+			issues: opts.required ? [{
+				path: "",
+				message: "no catalog at this path"
+			}] : []
+		};
+		const content = fs.read(file);
+		const issues = [...validateCatalogContent(target, content), ...parseAndCheckSources(root, fs, content)];
+		return {
+			target,
+			path: relative,
+			status: issues.length === 0 ? "valid" : "invalid",
+			issues
+		};
+	});
+}
+function parseAndCheckSources(root, fs, content) {
+	try {
+		return checkSources(root, fs, JSON.parse(content));
+	} catch {
+		return [];
+	}
+}
+//#endregion
 //#region src/marketplace/cli.ts
 function targetsFromOptions(opts) {
 	const targets = [
@@ -1443,7 +2730,7 @@ function targetsFromOptions(opts) {
 	return targets.length > 0 ? targets : void 0;
 }
 function initCommand() {
-	return new Command("init").description("Generate local marketplace metadata without publishing or provisioning").option("--claude", "Generate the Claude marketplace catalog").option("--codex", "Generate the Codex marketplace catalog").option("--copilot", "Generate the Copilot marketplace catalog").option("--cursor", "Generate the Cursor submission scaffold").option("--plugin-scan-dir <dir>", "Directory beneath --root to scan for root-level plugin.json files (repeatable)", (value, previous = []) => [...previous, value]).option("--name <name>", "Override the marketplace name").option("--owner <name>", "Override the marketplace owner").option("--dry-run", "Preview artifacts without writing them").option("--force", "Replace differing artifacts for selected targets").option("--format <format>", "Output format: toon or json (default: toon)").addOption(new Option("--json").hideHelp()).addOption(ROOT_OPTION).addHelpText("after", "\nExample:\n  $ universal-plugin marketplace init --root .\n").action((opts) => {
+	return new Command("init").description("Generate local marketplace metadata without publishing or provisioning").option("--claude", "Generate the Claude marketplace catalog").option("--codex", "Generate the Codex marketplace catalog").option("--copilot", "Generate the Copilot marketplace catalog").option("--cursor", "Generate the Cursor marketplace catalog").option("--plugin-scan-dir <dir>", "Directory beneath --root to scan for root-level plugin.json files (repeatable)", (value, previous = []) => [...previous, value]).option("--name <name>", "Override the marketplace name").option("--owner <name>", "Override the marketplace owner").option("--dry-run", "Preview artifacts without writing them").option("--force", "Replace differing artifacts for selected targets").option("--format <format>", "Output format: toon or json (default: toon)").addOption(new Option("--json").hideHelp()).addOption(ROOT_OPTION).addHelpText("after", "\nExample:\n  $ universal-plugin marketplace init --root .\n").action((opts) => {
 		try {
 			if (opts.format !== void 0 && opts.format !== "toon" && opts.format !== "json") throw new Error("error: --format must be \"toon\" or \"json\"");
 			const results = initializeMarketplace(resolveRoot(opts.root), {
@@ -1470,39 +2757,36 @@ function initCommand() {
 		}
 	});
 }
-function marketplaceCommand() {
-	return new Command("marketplace").description("Generate repository-local marketplace metadata").addCommand(initCommand());
-}
-//#endregion
-//#region src/vendor-registry/vendor-registry.ts
-function lookupVendor(registry, vendorId) {
-	return registry[vendorId] ?? null;
-}
-function mergeRegistries(base, override) {
-	const result = { ...base };
-	for (const [id, config] of Object.entries(override)) result[id] = {
-		...base[id] ?? {},
-		...config
-	};
-	return result;
-}
-//#endregion
-//#region src/vendor-registry/fs.ts
-function bundledRegistryPath() {
-	const thisFile = fileURLToPath(import.meta.url);
-	return path.join(path.dirname(thisFile), "data", "vendors.json");
-}
-function userOverridePath() {
-	return path.join(os.homedir(), ".agents", "universal-plugin-vendors.json");
+function validateCommand() {
+	return new Command("validate").description("Check the repository-local marketplace catalogs against the schema each runtime loads").option("--claude", "Validate the Claude marketplace catalog").option("--codex", "Validate the Codex marketplace catalog").option("--copilot", "Validate the Copilot marketplace catalog").option("--cursor", "Validate the Cursor marketplace catalog").option("--required", "Treat a selected target with no catalog as a failure").option("--format <format>", "Output format: toon or json (default: toon)").addOption(ROOT_OPTION).addHelpText("after", "\nExample:\n  $ universal-plugin marketplace validate --claude\n").action((opts) => {
+		try {
+			if (opts.format !== void 0 && opts.format !== "toon" && opts.format !== "json") throw new Error("error: --format must be \"toon\" or \"json\"");
+			const results = validateMarketplace(resolveRoot(opts.root), {
+				targets: targetsFromOptions(opts),
+				required: opts.required
+			});
+			output(results, {
+				targets: results.map((row) => ({
+					target: row.target,
+					status: row.status,
+					path: row.path,
+					issues: row.issues.length
+				})),
+				summary: `${results.filter((row) => row.status === "invalid").length} invalid of ${results.length}`
+			});
+			for (const row of results.filter((row) => row.status === "invalid")) {
+				process.stderr.write(formatCatalogIssues(row.path, row.issues));
+				process.stderr.write("\n");
+			}
+			if (results.some((row) => row.status === "invalid")) process.exitCode = 1;
+		} catch (err) {
+			process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+			process.exitCode = 1;
+		}
+	});
 }
-function loadRegistry() {
-	const bundled = JSON.parse(fsNode.readFileSync(bundledRegistryPath(), "utf8"));
-	try {
-		return mergeRegistries(bundled, JSON.parse(fsNode.readFileSync(userOverridePath(), "utf8")));
-	} catch (err) {
-		if (err.code === "ENOENT") return bundled;
-		throw err;
-	}
+function marketplaceCommand() {
+	return new Command("marketplace").description("Generate repository-local marketplace metadata").addCommand(initCommand()).addCommand(validateCommand());
 }
 //#endregion
 //#region src/prepare/fs.ts
@@ -1517,15 +2801,15 @@ function projectStatePath(root) {
 }
 function readStateFile(filePath) {
 	try {
-		return mergeSafeState(JSON.parse(fsNode.readFileSync(filePath, "utf8")));
+		return mergeSafeState(JSON.parse(fs.readFileSync(filePath, "utf8")));
 	} catch (err) {
 		if (err.code === "ENOENT") return null;
 		throw err;
 	}
 }
 function writeStateFile(filePath, state) {
-	fsNode.mkdirSync(path.dirname(filePath), { recursive: true });
-	fsNode.writeFileSync(filePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 function realPrepareFs(vendor, projectRoot) {
 	return {
@@ -1533,7 +2817,7 @@ function realPrepareFs(vendor, projectRoot) {
 			if (!vendor.globalManifest) return {};
 			const manifestPath = expandHome(vendor.globalManifest);
 			try {
-				const raw = JSON.parse(fsNode.readFileSync(manifestPath, "utf8"));
+				const raw = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
 				return Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, typeof v === "object" && v !== null && "version" in v ? String(v.version) : String(v)]));
 			} catch (err) {
 				if (err.code === "ENOENT") return {};
@@ -1707,9 +2991,9 @@ function prepareCommand() {
 //#endregion
 //#region src/version/fs.ts
 const realJsonIo = {
-	exists: (p) => fsNode.existsSync(p),
-	read: (p) => fsNode.readFileSync(p, "utf8"),
-	write: (p, content) => fsNode.writeFileSync(p, content)
+	exists: (p) => fs.existsSync(p),
+	read: (p) => fs.readFileSync(p, "utf8"),
+	write: (p, content) => fs.writeFileSync(p, content)
 };
 /** Reads `packagePath` from `.agents/universal-plugin.json`. Absent file, absent key, or a
 *  non-string value all mean "this plugin declares no npm package" — the manifest is then the only
@@ -1817,19 +3101,19 @@ function globalStatePath$1() {
 function realSelfUpdateFs(hookFilePaths) {
 	return {
 		globHookFiles: () => hookFilePaths,
-		readFile: (p) => fsNode.readFileSync(p, "utf8"),
-		writeFile: (p, c) => fsNode.writeFileSync(p, c, "utf8"),
+		readFile: (p) => fs.readFileSync(p, "utf8"),
+		writeFile: (p, c) => fs.writeFileSync(p, c, "utf8"),
 		readGlobalState: () => {
 			try {
-				return mergeSafeState(JSON.parse(fsNode.readFileSync(globalStatePath$1(), "utf8")));
+				return mergeSafeState(JSON.parse(fs.readFileSync(globalStatePath$1(), "utf8")));
 			} catch (err) {
 				if (err.code === "ENOENT") return emptyState();
 				throw err;
 			}
 		},
 		writeGlobalState: (s) => {
-			fsNode.mkdirSync(path.dirname(globalStatePath$1()), { recursive: true });
-			fsNode.writeFileSync(globalStatePath$1(), JSON.stringify(s, null, 2) + "\n");
+			fs.mkdirSync(path.dirname(globalStatePath$1()), { recursive: true });
+			fs.writeFileSync(globalStatePath$1(), JSON.stringify(s, null, 2) + "\n");
 		}
 	};
 }
@@ -1870,7 +3154,7 @@ function selfUpdateCommand() {
 			toVersion,
 			fs: realSelfUpdateFs(Object.values(registry).map((v) => v.hookGlob).filter((g) => g !== null).map((g) => g.replace("~", os.homedir())).filter((p) => {
 				try {
-					fsNode.accessSync(p);
+					fs.accessSync(p);
 					return true;
 				} catch {
 					return false;
@@ -1914,15 +3198,15 @@ function realSyncFs() {
 	return {
 		readGlobalState: () => {
 			try {
-				return mergeSafeState(JSON.parse(fsNode.readFileSync(globalStatePath(), "utf8")));
+				return mergeSafeState(JSON.parse(fs.readFileSync(globalStatePath(), "utf8")));
 			} catch (err) {
 				if (err.code === "ENOENT") return emptyState();
 				throw err;
 			}
 		},
 		writeGlobalState: (s) => {
-			fsNode.mkdirSync(path.dirname(globalStatePath()), { recursive: true });
-			fsNode.writeFileSync(globalStatePath(), JSON.stringify(s, null, 2) + "\n");
+			fs.mkdirSync(path.dirname(globalStatePath()), { recursive: true });
+			fs.writeFileSync(globalStatePath(), JSON.stringify(s, null, 2) + "\n");
 		},
 		shell: (cmd) => childProcess.spawnSync(cmd, {
 			shell: true,
@@ -1962,9 +3246,10 @@ function syncCommand() {
 *
 *  A version lives in five places, but only two are authored: the canonical `plugin.json` and, when
 *  the project declares a `packagePath`, that `package.json`. The per-vendor manifests
-*  (`plugin build`), the local marketplace catalogs (`marketplace init`), and the `npx`/`upx`
-*  pins in `skills/**` (`plugin bundle`) are all **derived** — re-derived by calling the command
-*  that owns them, never written a second time here. */
+*  (`plugin build`), the local marketplace catalog entries (`plugin build` refreshes the catalogs the
+*  repository carries, ADR-0014), and the `npx`/`upx` pins in `skills/**` (`plugin bundle`) are all
+*  **derived** — re-derived by calling the command that owns them, never written a second time
+*  here. */
 const RELEASE_TYPES = [
 	"major",
 	"minor",
@@ -1985,10 +3270,10 @@ function currentVersion(manifest) {
 /** Resolves the bump argument against the current version. An explicit version is used as given;
 *  a release type is applied to the current one, which must therefore exist. */
 function resolveTarget(current, opts) {
-	if (semver.valid(opts.bump)) return semver.valid(opts.bump);
+	if (semver$1.valid(opts.bump)) return semver$1.valid(opts.bump);
 	if (!isReleaseType(opts.bump)) throw new Error(`Unknown version or release type "${opts.bump}" — expected an explicit version (1.4.0) or one of: ${RELEASE_TYPES.join(", ")}`);
 	if (current === null) throw new Error("plugin.json has no version to bump from — pass an explicit version (e.g. 0.1.0) to set the first one");
-	const next = opts.preid === void 0 ? semver.inc(current, opts.bump) : semver.inc(current, opts.bump, opts.preid);
+	const next = opts.preid === void 0 ? semver$1.inc(current, opts.bump) : semver$1.inc(current, opts.bump, opts.preid);
 	if (next === null) throw new Error(`Current version "${current}" in plugin.json is not valid semver`);
 	return next;
 }
@@ -1998,7 +3283,7 @@ function planVersion(state, opts) {
 	if (!state.manifestExists || state.manifest === null) throw new Error("No plugin.json found at the project root");
 	const from = currentVersion(state.manifest);
 	const to = resolveTarget(from, opts);
-	if (from !== null && !semver.gt(to, from) && !opts.force) throw new Error(`Target version "${to}" does not advance on the current version "${from}" — pass --force to set it anyway`);
+	if (from !== null && !semver$1.gt(to, from) && !opts.force) throw new Error(`Target version "${to}" does not advance on the current version "${from}" — pass --force to set it anyway`);
 	if (state.packagePath !== null && state.packageJson === null) throw new Error(`No package.json found at packagePath "${state.packagePath}"`);
 	const rows = [{
 		path: "plugin.json",
@@ -2102,10 +3387,12 @@ function nextStep(dryRun, built) {
 const program = new Command();
 program.name("universal-plugin").description("Universal AI agent plugin build tool").version("0.0.0").helpCommand(false);
 function pluginCommand() {
-	const cmd = new Command("plugin").description("Author the canonical plugin manifest (build, bundle, init, version; validate planned)");
+	const cmd = new Command("plugin").description("Author the canonical plugin manifest (build, bundle, init, install, uninstall, version; validate planned)");
 	cmd.addCommand(buildCommand());
 	cmd.addCommand(bundleCommand());
 	cmd.addCommand(initCommand$1());
+	cmd.addCommand(installCommand());
+	cmd.addCommand(uninstallCommand());
 	cmd.addCommand(versionCommand());
 	return cmd;
 }