@hydraharness/harness-host-plugin-inventory 0.1.1-rc.10

package/lib/index.js

@@ -0,0 +1,1375 @@
+import { createRequire } from "node:module";
+import { execFile } from "node:child_process";
+import { lstat, mkdtemp, readFile, realpath, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Service } from "@hydraharness/cordis";
+import { profilePluginEnablement, readProfileManifest, resolveProfileDir } from "@hydraharness/harness-app-boot";
+import { withFileLock, writeFileAtomic } from "@hydraharness/harness-atomic-write";
+import { settingsNamespace } from "@hydraharness/harness-settings";
+import { Remote, TypertRemoteService } from "@hydraharness/harness-typert-protocol";
+import z from "@hydraharness/schemastery";
+import { z as z$1 } from "zod";
+//#region lib/types/index.js
+/** Runtime plugin inventory plus shared user-setting enablement controls. */
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+		else descriptor[key] = _;
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** Brand an existing Loader-tree entry id at the owning boundary. */
+function pluginEntryId(value) {
+	return value;
+}
+/** Runtime mirror: FiberState is a cross-package const enum. */
+const FIBER_STATE = {
+	PENDING: 0,
+	LOADING: 1,
+	ACTIVE: 2,
+	FAILED: 3,
+	DISPOSED: 4,
+	UNLOADING: 5
+};
+/** Complete public projection of Cordis Fiber states. */
+const FIBER_PHASE = {
+	[FIBER_STATE.PENDING]: "pending",
+	[FIBER_STATE.LOADING]: "loading",
+	[FIBER_STATE.ACTIVE]: "active",
+	[FIBER_STATE.FAILED]: "failed",
+	[FIBER_STATE.DISPOSED]: null,
+	[FIBER_STATE.UNLOADING]: "unloading"
+};
+const PLUGIN_SETTINGS_NAMESPACE = settingsNamespace("plugins");
+const MARKETPLACE_SETTINGS_NAMESPACE = settingsNamespace("plugin-marketplaces");
+const HMR_MODULE = "@hydraharness/cordis-plugin-hmr";
+const AGENT_PRESET_ENTRY_PREFIX = "agent-preset:";
+const MAX_MARKETPLACE_BYTES = 1024 * 1024;
+const MARKETPLACE_GIT_TIMEOUT_MS = 3e4;
+const MAX_MARKETPLACE_SPARSE_PATHS = 20;
+const MAX_MARKETPLACE_SPARSE_PATH_LENGTH = 512;
+const GITHUB_SHORTHAND_PATTERN = /^([A-Za-z0-9][A-Za-z0-9._-]*)\/([A-Za-z0-9][A-Za-z0-9._-]*)$/u;
+const MarketplaceDocumentSchema = z$1.object({ plugins: z$1.array(z$1.record(z$1.string(), z$1.unknown())).max(500) }).loose();
+const PluginMetadataSchema = z$1.object({
+	description: z$1.string().trim().min(1).optional(),
+	application: z$1.string().trim().min(1).optional()
+});
+const PluginPackageSchema = z$1.object({
+	description: PluginMetadataSchema.shape.description,
+	hydra: z$1.object({ plugin: z$1.object({ application: z$1.string().trim().min(1).optional() }).optional() }).optional()
+});
+/** Read presentation metadata without importing or activating the plugin. */
+async function pluginMetadata(moduleName, baseUrl, options = {}) {
+	const overrides = PluginMetadataSchema.parse(options);
+	const metadata = {
+		...overrides.description === void 0 ? {} : { description: overrides.description },
+		...overrides.application === void 0 ? {} : { application: overrides.application }
+	};
+	if (baseUrl === void 0 || moduleName.startsWith(".") || moduleName.startsWith("/") || moduleName.includes(":") || moduleName.includes("\\")) return metadata;
+	const packageName = moduleName.split("/").slice(0, moduleName.startsWith("@") ? 2 : 1).join("/");
+	let path;
+	try {
+		path = createRequire(baseUrl).resolve(`${packageName}/package.json`);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED")) return metadata;
+		throw error;
+	}
+	const result = PluginPackageSchema.safeParse(JSON.parse(await readFile(path, "utf8")));
+	if (!result.success) throw new Error(`pluginInventory: invalid plugin metadata in ${path}`, { cause: result.error });
+	const { description, hydra } = result.data;
+	return {
+		...description === void 0 ? {} : { description },
+		...hydra?.plugin?.application === void 0 ? {} : { application: hydra.plugin.application },
+		...metadata
+	};
+}
+const PluginSettingsSchema = z.object({ enabled: z.dict(z.boolean()).default({}) });
+const MarketplaceSourceSchema = z.object({
+	source: z.string(),
+	gitRef: z.string().default(""),
+	sparsePaths: z.array(z.string()).max(MAX_MARKETPLACE_SPARSE_PATHS).default([]),
+	enabled: z.boolean().default(true)
+});
+const MarketplaceSettingsSchema = z.object({ sources: z.array(MarketplaceSourceSchema).max(20).default([]) });
+function missingPath(error) {
+	return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+function normalizeGitRef(value) {
+	const gitRef = value?.trim();
+	if (gitRef === void 0 || gitRef === "") return void 0;
+	if (gitRef.length > 255 || gitRef.startsWith("-") || /[\u0000-\u0020\u007F]/u.test(gitRef)) throw new Error("pluginInventory: Git ref is invalid");
+	return gitRef;
+}
+function normalizeSparsePaths(values) {
+	if ((values?.length ?? 0) > MAX_MARKETPLACE_SPARSE_PATHS) throw new Error(`pluginInventory: at most ${String(MAX_MARKETPLACE_SPARSE_PATHS)} sparse paths are allowed`);
+	const paths = (values ?? []).map((value) => {
+		const path = value.trim().replaceAll("\\", "/").replace(/\/+$/u, "");
+		if (path.length > MAX_MARKETPLACE_SPARSE_PATH_LENGTH) throw new Error(`pluginInventory: sparse paths may contain at most ${String(MAX_MARKETPLACE_SPARSE_PATH_LENGTH)} characters`);
+		const segments = path.split("/");
+		if (path === "" || path.startsWith("/") || path.startsWith("-") || /^[A-Za-z]:\//u.test(path) || segments.some((segment) => segment === "" || segment === "." || segment === "..")) throw new Error(`pluginInventory: sparse path ${JSON.stringify(value)} must be repository-relative`);
+		return path;
+	});
+	return [...new Set(paths)].sort();
+}
+function normalizeGitSource(source) {
+	const shorthand = GITHUB_SHORTHAND_PATTERN.exec(source);
+	if (shorthand !== null) return `https://github.com/${shorthand[1] ?? ""}/${(shorthand[2] ?? "").replace(/\.git$/u, "")}.git`;
+	if (/^[A-Za-z0-9._-]+@[A-Za-z0-9.-]+:[A-Za-z0-9._~/-]+$/u.test(source)) return source;
+	let url;
+	try {
+		url = new URL(source);
+	} catch (cause) {
+		throw new Error("pluginInventory: source must be a GitHub repo, Git URL, or existing local folder", { cause });
+	}
+	if (url.protocol !== "https:" && url.protocol !== "ssh:") throw new Error("pluginInventory: remote marketplace source must use HTTPS or SSH");
+	if (url.password !== "" || url.hash !== "" || url.search !== "" || url.protocol === "https:" && url.username !== "") throw new Error("pluginInventory: marketplace source cannot contain credentials, a query, or a fragment");
+	return url.href;
+}
+async function normalizeMarketplaceSource(request) {
+	const source = request.source.trim();
+	if (source === "" || source.length > 2048 || /[\u0000-\u001F\u007F]/u.test(source)) throw new Error("pluginInventory: marketplace source is invalid");
+	const gitRef = normalizeGitRef(request.gitRef);
+	const sparsePaths = normalizeSparsePaths(request.sparsePaths);
+	const localPath = resolve(source);
+	try {
+		if (!GITHUB_SHORTHAND_PATTERN.test(source) && (await stat(localPath)).isDirectory()) {
+			if (gitRef !== void 0 || sparsePaths.length > 0) throw new Error("pluginInventory: Git ref and sparse paths require a Git source");
+			return {
+				kind: "local",
+				source: await realpath(localPath),
+				gitRef: "",
+				sparsePaths: [],
+				enabled: true
+			};
+		}
+	} catch (error) {
+		if (!missingPath(error)) throw error;
+	}
+	return {
+		kind: "git",
+		source: normalizeGitSource(source),
+		gitRef: gitRef ?? "",
+		sparsePaths,
+		enabled: true
+	};
+}
+function marketplaceGitEnv() {
+	const env = {};
+	for (const [name, value] of Object.entries(process.env)) if (!/(?:KEY|SECRET|TOKEN|PASSWORD)/iu.test(name)) env[name] = value;
+	env.GCM_INTERACTIVE = "Never";
+	env.GIT_TERMINAL_PROMPT = "0";
+	return env;
+}
+function runGit(cwd, args) {
+	return new Promise((resolvePromise, reject) => {
+		execFile("git", [
+			"-c",
+			"protocol.ext.allow=never",
+			"-c",
+			"protocol.file.allow=never",
+			...args
+		], {
+			cwd,
+			encoding: "utf8",
+			env: marketplaceGitEnv(),
+			maxBuffer: MAX_MARKETPLACE_BYTES,
+			timeout: MARKETPLACE_GIT_TIMEOUT_MS,
+			windowsHide: true
+		}, (error, _stdout, stderr) => {
+			if (error === null) {
+				resolvePromise();
+				return;
+			}
+			const detail = stderr.trim().split(/\r?\n/u)[0];
+			reject(new Error(`pluginInventory: failed to load Git marketplace${detail === void 0 || detail === "" ? "" : `: ${detail}`}`, { cause: error }));
+		});
+	});
+}
+async function readMarketplaceDocument(root) {
+	for (const relativePath of [
+		".agents/plugins/marketplace.json",
+		".agents/plugins/api_marketplace.json",
+		"marketplace.json"
+	]) {
+		const filename = join(root, relativePath);
+		try {
+			const metadata = await lstat(filename);
+			if (!metadata.isFile()) continue;
+			if (metadata.size > MAX_MARKETPLACE_BYTES) throw new Error(`pluginInventory: marketplace exceeds ${String(MAX_MARKETPLACE_BYTES)} bytes`);
+			const body = await readFile(filename);
+			if (body.byteLength > MAX_MARKETPLACE_BYTES) throw new Error(`pluginInventory: marketplace exceeds ${String(MAX_MARKETPLACE_BYTES)} bytes`);
+			return MarketplaceDocumentSchema.parse(JSON.parse(body.toString("utf8")));
+		} catch (error) {
+			if (missingPath(error)) continue;
+			throw error;
+		}
+	}
+	throw new Error("pluginInventory: OpenAI/Codex marketplace.json is missing");
+}
+/** Load and validate one marketplace root without retaining an executable checkout. */
+async function loadMarketplace(request) {
+	const { kind, ...source } = await normalizeMarketplaceSource(request);
+	if (kind === "local") return {
+		source,
+		document: await readMarketplaceDocument(source.source)
+	};
+	const tempRoot = await mkdtemp(join(tmpdir(), "hydra-marketplace-"));
+	const checkout = join(tempRoot, "repository");
+	try {
+		if (source.gitRef !== "") try {
+			await runGit(tempRoot, [
+				"check-ref-format",
+				"--allow-onelevel",
+				source.gitRef
+			]);
+		} catch (cause) {
+			throw new Error("pluginInventory: Git ref is invalid", { cause });
+		}
+		const cloneArgs = [
+			"clone",
+			"--depth",
+			"1",
+			"--filter=blob:none"
+		];
+		if (source.sparsePaths.length > 0) cloneArgs.push("--sparse");
+		if (source.gitRef !== "") cloneArgs.push("--no-checkout");
+		cloneArgs.push("--", source.source, checkout);
+		await runGit(tempRoot, cloneArgs);
+		if (source.gitRef !== "") await runGit(tempRoot, [
+			"-C",
+			checkout,
+			"fetch",
+			"--depth",
+			"1",
+			"origin",
+			source.gitRef
+		]);
+		if (source.sparsePaths.length > 0) await runGit(tempRoot, [
+			"-C",
+			checkout,
+			"sparse-checkout",
+			"set",
+			"--cone",
+			"--sparse-index",
+			"--",
+			".agents/plugins",
+			...source.sparsePaths
+		]);
+		if (source.gitRef !== "") await runGit(tempRoot, [
+			"-C",
+			checkout,
+			"checkout",
+			"--detach",
+			"FETCH_HEAD"
+		]);
+		return {
+			source,
+			document: await readMarketplaceDocument(checkout)
+		};
+	} finally {
+		await rm(tempRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Remote-only service exposing the Loader's current non-group entry state. */
+let PluginInventoryGateway = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _list_decorators;
+	let _setEnabled_decorators;
+	let _listMarketplaces_decorators;
+	let _addMarketplace_decorators;
+	let _setMarketplaceEnabled_decorators;
+	let _removeMarketplace_decorators;
+	let _listImportedPlugins_decorators;
+	let _importPlugin_decorators;
+	let _infoPlugin_decorators;
+	let _enablePlugin_decorators;
+	let _disablePlugin_decorators;
+	let _setPluginMcpServerEnabled_decorators;
+	let _setPluginMcpToolApproval_decorators;
+	let _trustPlugin_decorators;
+	let _untrustPlugin_decorators;
+	let _removePlugin_decorators;
+	let _listMcpServers_decorators;
+	let _defineMcpServer_decorators;
+	let _setMcpServerEnabled_decorators;
+	let _removeMcpServer_decorators;
+	let _listHookRecords_decorators;
+	let _defineHookRecord_decorators;
+	let _setHookRecordEnabled_decorators;
+	let _removeHookRecord_decorators;
+	return class PluginInventoryGateway extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_list_decorators = [Remote("list")];
+			_setEnabled_decorators = [Remote("setEnabled")];
+			_listMarketplaces_decorators = [Remote("listMarketplaces")];
+			_addMarketplace_decorators = [Remote("addMarketplace")];
+			_setMarketplaceEnabled_decorators = [Remote("setMarketplaceEnabled")];
+			_removeMarketplace_decorators = [Remote("removeMarketplace")];
+			_listImportedPlugins_decorators = [Remote("listImportedPlugins")];
+			_importPlugin_decorators = [Remote("importPlugin")];
+			_infoPlugin_decorators = [Remote("infoPlugin")];
+			_enablePlugin_decorators = [Remote("enablePlugin")];
+			_disablePlugin_decorators = [Remote("disablePlugin")];
+			_setPluginMcpServerEnabled_decorators = [Remote("setPluginMcpServerEnabled")];
+			_setPluginMcpToolApproval_decorators = [Remote("setPluginMcpToolApproval")];
+			_trustPlugin_decorators = [Remote("trustPlugin")];
+			_untrustPlugin_decorators = [Remote("untrustPlugin")];
+			_removePlugin_decorators = [Remote("removePlugin")];
+			_listMcpServers_decorators = [Remote("listMcpServers")];
+			_defineMcpServer_decorators = [Remote("defineMcpServer")];
+			_setMcpServerEnabled_decorators = [Remote("setMcpServerEnabled")];
+			_removeMcpServer_decorators = [Remote("removeMcpServer")];
+			_listHookRecords_decorators = [Remote("listHookRecords")];
+			_defineHookRecord_decorators = [Remote("defineHookRecord")];
+			_setHookRecordEnabled_decorators = [Remote("setHookRecordEnabled")];
+			_removeHookRecord_decorators = [Remote("removeHookRecord")];
+			__esDecorate(this, null, _list_decorators, {
+				kind: "method",
+				name: "list",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "list" in obj,
+					get: (obj) => obj.list
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setEnabled_decorators, {
+				kind: "method",
+				name: "setEnabled",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setEnabled" in obj,
+					get: (obj) => obj.setEnabled
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listMarketplaces_decorators, {
+				kind: "method",
+				name: "listMarketplaces",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listMarketplaces" in obj,
+					get: (obj) => obj.listMarketplaces
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _addMarketplace_decorators, {
+				kind: "method",
+				name: "addMarketplace",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "addMarketplace" in obj,
+					get: (obj) => obj.addMarketplace
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setMarketplaceEnabled_decorators, {
+				kind: "method",
+				name: "setMarketplaceEnabled",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setMarketplaceEnabled" in obj,
+					get: (obj) => obj.setMarketplaceEnabled
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _removeMarketplace_decorators, {
+				kind: "method",
+				name: "removeMarketplace",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "removeMarketplace" in obj,
+					get: (obj) => obj.removeMarketplace
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listImportedPlugins_decorators, {
+				kind: "method",
+				name: "listImportedPlugins",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listImportedPlugins" in obj,
+					get: (obj) => obj.listImportedPlugins
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _importPlugin_decorators, {
+				kind: "method",
+				name: "importPlugin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "importPlugin" in obj,
+					get: (obj) => obj.importPlugin
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _infoPlugin_decorators, {
+				kind: "method",
+				name: "infoPlugin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "infoPlugin" in obj,
+					get: (obj) => obj.infoPlugin
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _enablePlugin_decorators, {
+				kind: "method",
+				name: "enablePlugin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "enablePlugin" in obj,
+					get: (obj) => obj.enablePlugin
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _disablePlugin_decorators, {
+				kind: "method",
+				name: "disablePlugin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "disablePlugin" in obj,
+					get: (obj) => obj.disablePlugin
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setPluginMcpServerEnabled_decorators, {
+				kind: "method",
+				name: "setPluginMcpServerEnabled",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setPluginMcpServerEnabled" in obj,
+					get: (obj) => obj.setPluginMcpServerEnabled
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setPluginMcpToolApproval_decorators, {
+				kind: "method",
+				name: "setPluginMcpToolApproval",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setPluginMcpToolApproval" in obj,
+					get: (obj) => obj.setPluginMcpToolApproval
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _trustPlugin_decorators, {
+				kind: "method",
+				name: "trustPlugin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "trustPlugin" in obj,
+					get: (obj) => obj.trustPlugin
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _untrustPlugin_decorators, {
+				kind: "method",
+				name: "untrustPlugin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "untrustPlugin" in obj,
+					get: (obj) => obj.untrustPlugin
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _removePlugin_decorators, {
+				kind: "method",
+				name: "removePlugin",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "removePlugin" in obj,
+					get: (obj) => obj.removePlugin
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listMcpServers_decorators, {
+				kind: "method",
+				name: "listMcpServers",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listMcpServers" in obj,
+					get: (obj) => obj.listMcpServers
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _defineMcpServer_decorators, {
+				kind: "method",
+				name: "defineMcpServer",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "defineMcpServer" in obj,
+					get: (obj) => obj.defineMcpServer
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setMcpServerEnabled_decorators, {
+				kind: "method",
+				name: "setMcpServerEnabled",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setMcpServerEnabled" in obj,
+					get: (obj) => obj.setMcpServerEnabled
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _removeMcpServer_decorators, {
+				kind: "method",
+				name: "removeMcpServer",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "removeMcpServer" in obj,
+					get: (obj) => obj.removeMcpServer
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listHookRecords_decorators, {
+				kind: "method",
+				name: "listHookRecords",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listHookRecords" in obj,
+					get: (obj) => obj.listHookRecords
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _defineHookRecord_decorators, {
+				kind: "method",
+				name: "defineHookRecord",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "defineHookRecord" in obj,
+					get: (obj) => obj.defineHookRecord
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setHookRecordEnabled_decorators, {
+				kind: "method",
+				name: "setHookRecordEnabled",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setHookRecordEnabled" in obj,
+					get: (obj) => obj.setHookRecordEnabled
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _removeHookRecord_decorators, {
+				kind: "method",
+				name: "removeHookRecord",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "removeHookRecord" in obj,
+					get: (obj) => obj.removeHookRecord
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static inject = ["loader", "settings"];
+		static Config = z.object({ compositionEntryIds: z.array(z.string()).default([]) });
+		compositionEntryIds = __runInitializers(this, _instanceExtraInitializers);
+		settings;
+		marketplaceSettings;
+		defaultEnabled = /* @__PURE__ */ new Map();
+		initialEnabled = /* @__PURE__ */ new Map();
+		originalConfigs = /* @__PURE__ */ new Map();
+		suspended = /* @__PURE__ */ new Map();
+		required = /* @__PURE__ */ new Set();
+		appliedSettings = /* @__PURE__ */ new Set();
+		restartEnablement = {};
+		mutationTail = Promise.resolve();
+		constructor(ctx, config = {}) {
+			super(ctx, "pluginInventory");
+			this.compositionEntryIds = new Set(config.compositionEntryIds);
+			this.settings = ctx.settings.register(PLUGIN_SETTINGS_NAMESPACE, PluginSettingsSchema);
+			this.marketplaceSettings = ctx.settings.register(MARKETPLACE_SETTINGS_NAMESPACE, MarketplaceSettingsSchema);
+			ctx.inject(["optionalPlugins"], (pctx) => {
+				pctx.effect(() => pctx.optionalPlugins.subscribe((enabled) => {
+					this.enqueue(() => this.applyOptionalGate(enabled)).catch((error) => {
+						this.ctx.logger.error(error);
+					});
+				}), "pluginInventory: optional policy");
+				this.enqueue(() => this.applyOptionalGate(pctx.optionalPlugins.enabled)).catch((error) => {
+					this.ctx.logger.error(error);
+				});
+			});
+			ctx.on("loader/config-update", () => {
+				const policy = ctx.get("optionalPlugins");
+				if (policy !== void 0) this.enqueue(() => this.applyOptionalGate(policy.enabled)).catch((error) => {
+					ctx.logger.error(error);
+				});
+			});
+		}
+		async [Service.init]() {
+			const rootInclude = this.rootInclude();
+			if (rootInclude === void 0) return;
+			const representatives = this.representatives(rootInclude);
+			for (const entry of representatives.values()) {
+				this.defaultEnabled.set(entry.options.name, !entry.disabled && !this.isHmrWatchOnly(entry));
+				this.originalConfigs.set(entry.options.name, structuredClone(entry.options.config));
+			}
+			if ([...representatives.values()].some((entry) => this.isRestartOnly(entry))) this.restartEnablement = profilePluginEnablement(readProfileManifest("pluginInventory", this.profileDir()));
+			await this.applySettings(this.settings.get().enabled);
+			for (const entry of representatives.values()) this.initialEnabled.set(entry.id, this.enabled(entry));
+			this.ctx.effect(() => this.settings.watch((next) => this.enqueue(() => this.applySettings(next.enabled))), "pluginInventory.settingsWatch");
+		}
+		/** Protect required modules and their declared dependency closure before suspending root-owned features. */
+		async applyOptionalGate(enabled) {
+			const policy = this.ctx.get("optionalPlugins");
+			if (policy === void 0) return;
+			if (!enabled) await policy.drain();
+			if (policy.enabled !== enabled) return;
+			const entries = [...this.representatives(this.rootInclude()).values()];
+			const byModule = new Map(entries.map((entry) => [entry.options.name, entry]));
+			const pending = entries.filter((entry) => entry.options.pluginRequired === true).map((entry) => entry.options.name);
+			this.required.clear();
+			for (const name of pending) {
+				if (this.required.has(name)) continue;
+				this.required.add(name);
+				const baseUrl = byModule.get(name)?.parent.tree.ctx.baseUrl;
+				if (baseUrl === void 0 || !name.startsWith("@")) continue;
+				const packageName = name.split("/").slice(0, 2).join("/");
+				const manifest = createRequire(baseUrl).resolve(`${packageName}/package.json`);
+				const metadata = z$1.object({
+					dependencies: z$1.record(z$1.string(), z$1.string()).optional(),
+					peerDependencies: z$1.record(z$1.string(), z$1.string()).optional(),
+					hydra: z$1.object({ bundle: z$1.unknown().optional() }).optional()
+				}).parse(JSON.parse(await readFile(manifest, "utf8")));
+				if (metadata.hydra?.bundle !== void 0) continue;
+				for (const dependency of Object.keys({
+					...metadata.dependencies,
+					...metadata.peerDependencies
+				})) for (const candidate of entries) if (candidate.options.name === dependency || candidate.options.name.startsWith(`${dependency}/`)) pending.push(candidate.options.name);
+			}
+			for (const entry of entries) {
+				if (entry.subtree !== void 0 || entry.subgroup !== void 0 || this.required.has(entry.options.name)) continue;
+				const previous = this.suspended.get(entry);
+				if (!enabled) {
+					if (!this.suspended.has(entry)) this.suspended.set(entry, !entry.disabled);
+					await entry.update({ disabled: true });
+				} else if (previous !== void 0) {
+					const nextEnabled = this.isRestartOnly(entry) ? previous : this.settings.get().enabled[entry.options.name] ?? this.defaultEnabled.get(entry.options.name) ?? previous;
+					this.suspended.delete(entry);
+					await entry.update({ disabled: !nextEnabled });
+				}
+			}
+		}
+		rootInclude() {
+			return Object.values(this.ctx.loader.store).map((entry) => entry.subtree).find((tree) => tree !== void 0 && "filename" in tree && typeof tree.filename === "string");
+		}
+		/** Project persisted OpenAI/Codex marketplace sources without exposing their entries here. */
+		async marketplaceSnapshot() {
+			const sources = this.marketplaceSettings.get().sources;
+			if (sources.length === 0) return { marketplaces: [] };
+			const marketplaces = [];
+			for (const source of sources) {
+				const sourceView = {
+					source: source.source,
+					...source.gitRef === "" ? {} : { gitRef: source.gitRef },
+					sparsePaths: source.sparsePaths,
+					enabled: source.enabled
+				};
+				try {
+					await loadMarketplace(source);
+					marketplaces.push({
+						status: "ready",
+						...sourceView
+					});
+				} catch {
+					marketplaces.push({
+						status: "unavailable",
+						...sourceView
+					});
+				}
+			}
+			return { marketplaces };
+		}
+		moduleEntries(moduleName) {
+			const entries = [];
+			for (const entry of this.ctx.loader.entries()) if (!entry.options.group && !this.compositionEntryIds.has(entry.options.id) && entry.options.name === moduleName) entries.push(entry);
+			return entries;
+		}
+		/** One logical row per module, preferring the profile-owned entry. */
+		representatives(rootInclude) {
+			const entries = /* @__PURE__ */ new Map();
+			for (const entry of this.ctx.loader.entries()) {
+				if (entry.options.group || this.compositionEntryIds.has(entry.options.id)) continue;
+				this.isRestartOnly(entry);
+				if (entry.options.pluginRequired !== void 0 && typeof entry.options.pluginRequired !== "boolean") throw new Error(`pluginInventory: ${entry.id}.pluginRequired must be boolean`);
+				const group = entry.options.pluginGroup;
+				if (group !== void 0 && (typeof group !== "string" || group.trim() === "")) throw new Error(`pluginInventory: ${entry.id}.pluginGroup must be a non-empty string`);
+				if ("plugin_type" in entry.options) throw new Error(`pluginInventory: ${entry.id}.plugin_type: use pluginType`);
+				const current = entries.get(entry.options.name);
+				if (current === void 0 || entry.parent.tree === rootInclude && current.parent.tree !== rootInclude || this.isRestartOnly(entry) && !this.isRestartOnly(current)) entries.set(entry.options.name, entry);
+			}
+			return entries;
+		}
+		/** Whether changing this root entry must wait for the next profile boot. */
+		isRestartOnly(entry) {
+			const value = entry.options.pluginType;
+			if (value !== void 0 && value !== "core" && value !== "normal") throw new Error(`pluginInventory: ${entry.id}.pluginType must be core or normal`);
+			return value === "core" || entry.options.pluginGroup !== void 0 && [...this.ctx.loader.entries()].some((candidate) => candidate.options.pluginGroup === entry.options.pluginGroup && candidate.options.pluginType === "core");
+		}
+		isToggleable(entry, rootInclude = this.rootInclude()) {
+			return rootInclude !== void 0 && entry.parent.tree === rootInclude && entry.options.pluginRequired !== true && !this.required.has(entry.options.name);
+		}
+		enabled(entry) {
+			if (this.isRestartOnly(entry) || !this.isToggleable(entry)) return this.suspended.get(entry) ?? !entry.disabled;
+			return this.settings.get().enabled[entry.options.name] ?? this.defaultEnabled.get(entry.options.name) ?? !entry.disabled;
+		}
+		/** Desired state used by the switch; restart-only entries retain the live Loader state until reboot. */
+		desiredEnabled(entry) {
+			return this.isRestartOnly(entry) ? this.restartEnablement[entry.options.id] ?? !entry.disabled : this.enabled(entry);
+		}
+		/** Whether the currently loaded entry still differs from its persisted desired state. */
+		restartRequired(entry) {
+			const pending = this.restartEnablement[entry.options.id];
+			return this.isRestartOnly(entry) && pending !== void 0 && pending !== !entry.disabled;
+		}
+		/** Resolve the active root Include to the profile directory the launcher owns. */
+		profileDir() {
+			const filename = this.rootInclude()?.filename;
+			/* v8 ignore next -- Restart updates only follow a synchronous rootInclude-backed toggleability check. */
+			if (typeof filename !== "string") throw new Error("pluginInventory: active profile root is unavailable");
+			/* v8 ignore next -- The root Include stores filename as the filesystem path returned by fileURLToPath. */
+			const path = filename.startsWith("file:") ? fileURLToPath(filename) : filename;
+			const actual = resolve(dirname(path));
+			const expected = resolve(resolveProfileDir(basename(actual)));
+			if (actual !== expected) throw new Error(`pluginInventory: active root ${path} is not a managed hydra profile`);
+			return expected;
+		}
+		/** Persist one restart-only root switch without changing the live Loader tree. */
+		async setRestartEnabled(entries, enabled) {
+			const profileDir = this.profileDir();
+			const manifestPath = join(profileDir, "package.json");
+			await withFileLock(manifestPath, async () => {
+				const manifest = readProfileManifest("pluginInventory", profileDir);
+				const pluginEnablement = {
+					...profilePluginEnablement(manifest),
+					...Object.fromEntries(entries.map((entry) => [entry.options.id, enabled]))
+				};
+				const next = {
+					...manifest,
+					hydra: {
+						...manifest.hydra,
+						profile: {
+							...manifest.hydra?.profile,
+							pluginEnablement
+						}
+					}
+				};
+				await writeFileAtomic(manifestPath, `${JSON.stringify(next, void 0, 2)}\n`, { mode: 384 });
+				this.restartEnablement = pluginEnablement;
+			});
+		}
+		isHmrWatchOnly(entry) {
+			const config = entry.options.config;
+			return entry.options.name === HMR_MODULE && Array.isArray(config?.root) && config.root.length === 0;
+		}
+		enqueue(task) {
+			const run = this.mutationTail.then(task, task);
+			this.mutationTail = run.then(() => void 0, () => void 0);
+			return run;
+		}
+		async restore(states) {
+			for (const state of states.toReversed()) await state.entry.update({
+				disabled: state.disabled ?? null,
+				config: state.config ?? null
+			});
+		}
+		/** Keep one configured instance active; HMR's disabled state remains watch-only. */
+		async updateModule(entry, enabled) {
+			const candidates = this.moduleEntries(entry.options.name);
+			const states = candidates.map((candidate) => ({
+				entry: candidate,
+				disabled: candidate.options.disabled,
+				config: candidate.options.config
+			}));
+			try {
+				for (const candidate of candidates) if (candidate !== entry && !candidate.disabled) await candidate.update({ disabled: true });
+				if (entry.options.name === HMR_MODULE) {
+					const config = { ...this.originalConfigs.get(entry.options.name) };
+					if (enabled) delete config.root;
+					else config.root = [];
+					await entry.update({
+						disabled: null,
+						config
+					});
+				} else await entry.update({ disabled: enabled ? null : true });
+				return states;
+			} catch (error) {
+				try {
+					await this.restore(states);
+				} catch (rollbackError) {
+					throw new AggregateError([error, rollbackError], `pluginInventory: failed to update and roll back ${entry.options.name}`);
+				}
+				throw error;
+			}
+		}
+		async applySettings(enabled) {
+			const rootInclude = this.rootInclude();
+			const representatives = this.representatives(rootInclude);
+			const modules = new Set([...this.appliedSettings, ...Object.keys(enabled)]);
+			this.appliedSettings.clear();
+			for (const moduleName of Object.keys(enabled)) this.appliedSettings.add(moduleName);
+			const failures = [];
+			for (const moduleName of modules) {
+				const entry = representatives.get(moduleName);
+				if (entry === void 0) continue;
+				if (!this.isToggleable(entry, rootInclude) || this.isRestartOnly(entry)) continue;
+				const desired = enabled[moduleName] ?? this.defaultEnabled.get(moduleName) ?? !entry.disabled;
+				try {
+					await this.updateModule(entry, this.ctx.get("optionalPlugins")?.enabled === false && !this.required.has(moduleName) ? false : desired);
+				} catch (error) {
+					failures.push(error);
+				}
+			}
+			if (failures.length === 1) throw failures[0];
+			if (failures.length > 1) throw new AggregateError(failures, "pluginInventory: failed to apply plugin settings");
+		}
+		/**
+		* Read the Loader and optional preset roster directly on every call. Cordis's
+		* internal plugin/status events already maintain Entry.fiber and Fiber state,
+		* so a second Host cache would only add another lifecycle truth to synchronize.
+		* @returns Current Host entries followed by preset-owned leaf entries.
+		*/
+		async hostEntries() {
+			const rootInclude = this.rootInclude();
+			return Promise.all(this.inventoryGroups(rootInclude).map(async (group) => {
+				const entry = group[0];
+				const members = group.filter((candidate) => this.isToggleable(candidate, rootInclude));
+				const controlled = members.length > 0 ? members : group;
+				const initialStates = controlled.map((candidate) => this.initialEnabled.get(candidate.id) ?? this.enabled(candidate));
+				const desiredStates = controlled.map((candidate) => this.desiredEnabled(candidate));
+				const enabled = controlled.every((candidate) => this.enabled(candidate));
+				const restartRequired = controlled.some((candidate) => this.restartRequired(candidate));
+				const pendingEnabled = restartRequired ? controlled.every((candidate) => this.desiredEnabled(candidate)) : void 0;
+				const fiber = (enabled ? this.moduleEntries(entry.options.name).find((candidate) => !candidate.disabled && candidate.fiber !== void 0) : void 0)?.fiber;
+				return {
+					entryId: pluginEntryId(entry.id),
+					moduleName: entry.options.name,
+					...await pluginMetadata(entry.options.name, entry.parent.tree.ctx.baseUrl, entry.options),
+					pluginType: group.some((candidate) => this.isRestartOnly(candidate)) ? "core" : "normal",
+					...entry.options.pluginRequired === true || this.required.has(entry.options.name) ? { required: true } : {},
+					initialEnabled: initialStates.every(Boolean) ? true : initialStates.some(Boolean) ? null : false,
+					changedSinceStart: controlled.some((candidate, index) => this.desiredEnabled(candidate) !== initialStates[index]),
+					...desiredStates.some(Boolean) && !desiredStates.every(Boolean) ? { mixedEnabled: true } : {},
+					...group.length > 1 ? { relatedModules: group.slice(1).map((candidate) => candidate.options.name) } : {},
+					enabled,
+					...pendingEnabled === void 0 ? {} : { pendingEnabled },
+					restartRequired,
+					toggleable: this.isToggleable(entry, rootInclude),
+					fiberPhase: fiber === void 0 ? null : FIBER_PHASE[fiber.state]
+				};
+			}));
+		}
+		async presetEntries(presets, settings, target = {}) {
+			if (presets === void 0) return [];
+			const entries = settings === void 0 ? await presets.listPluginEntries() : await presets.listPluginEntries(settings);
+			return Promise.all(entries.map(async (entry) => ({
+				entryId: pluginEntryId(entry.entryId),
+				moduleName: entry.moduleName,
+				...await pluginMetadata(entry.moduleName, this.ctx.baseUrl, entry),
+				enabled: entry.enabled,
+				presetId: entry.presetId,
+				...entry.rowId === void 0 ? {} : { presetRowId: entry.rowId },
+				newSessionsOnly: true,
+				initialEnabled: this.initialEnabled.get(this.initialKey(entry.entryId, target)) ?? entry.enabled,
+				restartRequired: false,
+				toggleable: true,
+				fiberPhase: null
+			})));
+		}
+		/**
+		* List Host entries and preset leaves, or only the selected workspace's preset leaves.
+		* @param request - Workspace and editable settings layer; omission selects global inventory.
+		* @returns the current inventory projection.
+		*/
+		async list(request) {
+			const target = request ?? {};
+			this.assertTarget(target);
+			const workspace = target.workspaceId === void 0 ? void 0 : await this.workspaceTarget(target.workspaceId, target.layer);
+			const selected = workspace?.target ?? {};
+			const entries = workspace === void 0 ? [...await this.hostEntries(), ...await this.presetEntries(this.agentPresets())] : await this.presetEntries(workspace.presets, workspace.settings, selected);
+			for (const entry of entries) {
+				const key = this.initialKey(entry.entryId, selected);
+				if (!this.initialEnabled.has(key)) this.initialEnabled.set(key, entry.enabled);
+			}
+			return {
+				entries,
+				...selected
+			};
+		}
+		/** Keep initial preset states separate for global and workspace settings files. */
+		initialKey(entryId, target) {
+			return target.workspaceId === void 0 ? entryId : `${target.workspaceId}:${target.layer ?? "local"}:${entryId}`;
+		}
+		/** Group only explicitly related entries, preferring a persistently editable owner. */
+		inventoryGroups(rootInclude) {
+			const groups = /* @__PURE__ */ new Map();
+			for (const entry of this.representatives(rootInclude).values()) {
+				const key = entry.options.pluginGroup === void 0 ? `module:${entry.options.name}` : `group:${entry.options.pluginGroup}:${entry.options.pluginRequired === true || this.required.has(entry.options.name) ? "required" : "optional"}`;
+				const group = groups.get(key) ?? [];
+				if (this.isToggleable(entry, rootInclude) && group[0] !== void 0 && !this.isToggleable(group[0], rootInclude)) group.unshift(entry);
+				else group.push(entry);
+				groups.set(key, group);
+			}
+			return [...groups.values()];
+		}
+		/**
+		* Persist a restart-only root state without live unload, or apply one normal
+		* module-wide live state and persist it in the shared settings document.
+		* @param request - Target entry, desired enablement, and optional workspace settings file.
+		* @returns The fresh snapshot and whether this mutation needs a restart.
+		*/
+		setEnabled(request) {
+			this.assertTarget(request);
+			return this.enqueue(async () => {
+				const workspace = request.workspaceId === void 0 ? void 0 : await this.workspaceTarget(request.workspaceId, request.layer);
+				if (workspace !== void 0 && !request.entryId.startsWith(AGENT_PRESET_ENTRY_PREFIX)) throw new Error("pluginInventory: workspace settings can change only agent preset entries");
+				if (request.entryId.startsWith(AGENT_PRESET_ENTRY_PREFIX)) {
+					const presets = workspace === void 0 ? this.agentPresets() : workspace.presets;
+					if (presets === void 0) throw new Error("pluginInventory: agent preset controls are unavailable");
+					const entry = (workspace === void 0 ? await presets.listPluginEntries() : await presets.listPluginEntries(workspace.settings)).find((candidate) => candidate.entryId === request.entryId);
+					if (entry === void 0) throw new Error(`pluginInventory: preset entry ${request.entryId} cannot be toggled in-app`);
+					const key = this.initialKey(entry.entryId, workspace?.target ?? {});
+					if (!this.initialEnabled.has(key)) this.initialEnabled.set(key, entry.enabled);
+					if (entry.enabled !== request.enabled) if (workspace === void 0) await presets.setPluginEnabled(entry.entryId, request.enabled);
+					else await presets.setPluginEnabled(entry.entryId, request.enabled, workspace.settings);
+					return {
+						snapshot: await this.list(workspace?.target),
+						restartRequired: false
+					};
+				}
+				const resolved = this.ctx.loader.resolve(request.entryId);
+				const rootInclude = this.rootInclude();
+				const group = this.inventoryGroups(rootInclude).find((candidates) => candidates.some((candidate) => candidate.options.name === resolved.options.name)) ?? [];
+				const entry = group[0];
+				if (entry === void 0 || !this.isToggleable(entry, rootInclude)) throw new Error(`pluginInventory: entry ${request.entryId} cannot be toggled in-app`);
+				const members = group.filter((candidate) => this.isToggleable(candidate, rootInclude));
+				if (members.every((candidate) => request.enabled === this.desiredEnabled(candidate))) return {
+					snapshot: await this.list(),
+					restartRequired: members.some((candidate) => this.restartRequired(candidate))
+				};
+				if (group.some((candidate) => this.isRestartOnly(candidate))) {
+					await this.setRestartEnabled(members, request.enabled);
+					return {
+						snapshot: await this.list(),
+						restartRequired: members.some((candidate) => this.restartRequired(candidate))
+					};
+				}
+				const states = [];
+				try {
+					for (const member of members) states.push(...await this.updateModule(member, request.enabled));
+					await this.settings.update({ enabled: Object.fromEntries(members.map((member) => [member.options.name, request.enabled])) });
+				} catch (error) {
+					try {
+						await this.restore(states);
+					} catch (rollbackError) {
+						throw new AggregateError([error, rollbackError], `pluginInventory: failed to persist and roll back ${request.entryId}`);
+					}
+					throw error;
+				}
+				return {
+					snapshot: await this.list(),
+					restartRequired: false
+				};
+			});
+		}
+		/**
+		* Project every persisted OpenAI/Codex marketplace source.
+		* @returns OpenAI/Codex marketplace sources in persisted order.
+		*/
+		listMarketplaces() {
+			return this.marketplaceSnapshot();
+		}
+		/**
+		* Persist one validated OpenAI/Codex marketplace source, replacing any source of the same location.
+		* @param request - marketplace location with its optional Git ref and sparse paths.
+		* @returns The refreshed OpenAI/Codex marketplace source list.
+		*/
+		addMarketplace(request) {
+			return this.enqueue(async () => {
+				const loaded = await loadMarketplace(request);
+				const sources = this.marketplaceSettings.get().sources;
+				const existing = sources.findIndex((source) => source.source === loaded.source.source);
+				const entry = {
+					...loaded.source,
+					enabled: sources[existing]?.enabled ?? true
+				};
+				const next = existing === -1 ? [...sources, entry] : sources.map((source, index) => index === existing ? entry : source);
+				await this.marketplaceSettings.update({ sources: next });
+				return this.marketplaceSnapshot();
+			});
+		}
+		/**
+		* Enable or disable one marketplace slot, cascading to its imported plugins.
+		* @param request - marketplace source and its desired enablement.
+		* @returns The refreshed OpenAI/Codex marketplace source list.
+		*/
+		setMarketplaceEnabled(request) {
+			return this.enqueue(async () => {
+				const sources = this.marketplaceSettings.get().sources;
+				const index = sources.findIndex((candidate) => candidate.source === request.source);
+				if (index === -1) throw new Error(`pluginInventory: marketplace ${request.source} is not configured`);
+				const next = sources.map((candidate, position) => position === index ? {
+					...candidate,
+					enabled: request.enabled
+				} : candidate);
+				await this.marketplaceSettings.update({ sources: next });
+				await this.cascadeMarketplacePlugins(request.source, (runtime, identity) => request.enabled ? runtime.enable(identity) : runtime.disable(identity));
+				return this.marketplaceSnapshot();
+			});
+		}
+		/**
+		* Remove one persisted OpenAI/Codex marketplace source and uninstall its imported plugins.
+		* @param source - the persisted marketplace location to delete.
+		* @returns The refreshed OpenAI/Codex marketplace source list.
+		*/
+		removeMarketplace(source) {
+			return this.enqueue(async () => {
+				if (!this.marketplaceSettings.get().sources.some((candidate) => candidate.source === source)) throw new Error(`pluginInventory: marketplace ${source} is not configured`);
+				await this.cascadeMarketplacePlugins(source, (runtime, identity) => runtime.remove(identity));
+				const next = this.marketplaceSettings.get().sources.filter((candidate) => candidate.source !== source);
+				await this.marketplaceSettings.update({ sources: next });
+				return await this.marketplaceSnapshot();
+			});
+		}
+		/**
+		* Apply one lifecycle action to every plugin imported from this marketplace root.
+		* A no-op when the imported-plugin runtime is not part of this composition.
+		*/
+		async cascadeMarketplacePlugins(marketplace, action) {
+			const runtime = this.ctx.get("importedPlugins");
+			if (runtime === void 0) return;
+			const plugins = (await runtime.list()).plugins.filter((plugin) => plugin.source.marketplace === marketplace);
+			const failures = [];
+			for (const plugin of plugins) try {
+				await action(runtime, plugin.identity);
+			} catch (error) {
+				failures.push(error);
+			}
+			if (failures.length === 1) throw failures[0];
+			if (failures.length > 1) throw new AggregateError(failures, `pluginInventory: failed to update plugins for marketplace ${marketplace}`);
+		}
+		/**
+		* List source-qualified imported OpenAI/Codex plugin bundles.
+		* @returns Current imported-plugin projection.
+		*/
+		listImportedPlugins() {
+			return this.importedPlugins().list();
+		}
+		/**
+		* Stage a direct local/Git source or marketplace bundle through the shared runtime.
+		* @param source - Plugin source to import.
+		* @returns Current imported-plugin projection.
+		*/
+		importPlugin(source) {
+			return this.importedPlugins().import(source);
+		}
+		/**
+		* Read one imported bundle by source-qualified identity or an unambiguous name.
+		* @param identityOrName - Source-qualified identity or unambiguous plugin name.
+		* @returns Current plugin projection.
+		*/
+		infoPlugin(identityOrName) {
+			return this.importedPlugins().info(identityOrName);
+		}
+		/**
+		* Enable and load one imported bundle without changing native Hydra package state.
+		* @param identityOrName - Source-qualified identity or unambiguous plugin name.
+		* @returns Current imported-plugin projection.
+		*/
+		enablePlugin(identityOrName) {
+			return this.importedPlugins().enable(identityOrName);
+		}
+		/**
+		* Disable and deterministically unload one imported bundle.
+		* @param identityOrName - Source-qualified identity or unambiguous plugin name.
+		* @returns Current imported-plugin projection.
+		*/
+		disablePlugin(identityOrName) {
+			return this.importedPlugins().disable(identityOrName);
+		}
+		/**
+		* Change one imported plugin MCP server without changing hook trust.
+		* @param request - plugin identity, server name, and desired enablement.
+		* @returns Current imported-plugin projection.
+		*/
+		setPluginMcpServerEnabled(request) {
+			return this.importedPlugins().setMcpServerEnabled(request.identity, request.server, request.enabled);
+		}
+		/**
+		* Set one imported MCP tool's approval mode without changing server enablement.
+		* @param request - Plugin identity, server, tool, and approval mode.
+		* @returns Current imported-plugin projection.
+		*/
+		setPluginMcpToolApproval(request) {
+			return this.importedPlugins().setMcpToolApproval(request.identity, request.server, request.tool, request.approval);
+		}
+		/**
+		* Trust only the current hook definitions; MCP/tool approval remains independent.
+		* @param identityOrName - Source-qualified identity or unambiguous plugin name.
+		* @returns Current imported-plugin projection.
+		*/
+		trustPlugin(identityOrName) {
+			return this.importedPlugins().trustHooks(identityOrName);
+		}
+		/**
+		* Revoke hook trust without disabling other plugin components.
+		* @param identityOrName - Source-qualified identity or unambiguous plugin name.
+		* @returns Current imported-plugin projection.
+		*/
+		untrustPlugin(identityOrName) {
+			return this.importedPlugins().untrustHooks(identityOrName);
+		}
+		/**
+		* Remove one imported bundle and its writable plugin data.
+		* @param identityOrName - Source-qualified identity or unambiguous plugin name.
+		* @returns Current imported-plugin projection.
+		*/
+		removePlugin(identityOrName) {
+			return this.importedPlugins().remove(identityOrName);
+		}
+		/**
+		* List the user's own MCP server records with their live state.
+		* @param request - Workspace to inspect; omission selects the user's global records.
+		* @returns Selected settings records with runtime status and the workspace target.
+		*/
+		listMcpServers(request) {
+			const target = request ?? {};
+			this.assertTarget(target);
+			if (target.workspaceId !== void 0) return this.workspaceTarget(target.workspaceId, target.layer).then(({ ctx, settings, target: selected }) => ({
+				...this.mcpServers(ctx).list(settings),
+				...selected
+			}));
+			return Promise.resolve(this.mcpServers().list());
+		}
+		/**
+		* Store one complete MCP server definition and converge its mount.
+		* @param request - Complete server definition and optional workspace file to edit.
+		* @returns Refreshed MCP record projection.
+		*/
+		defineMcpServer(request) {
+			this.assertTarget(request);
+			if (request.workspaceId !== void 0) return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+				const registry = this.mcpServers(ctx);
+				await registry.define(request, settings);
+				return {
+					...registry.list(settings),
+					...target
+				};
+			});
+			return this.mcpServers().define(request);
+		}
+		/**
+		* Change one MCP record's desired state without touching its definition.
+		* @param request - Target record, desired state, and optional workspace file to edit.
+		* @returns Refreshed MCP record projection.
+		*/
+		setMcpServerEnabled(request) {
+			this.assertTarget(request);
+			if (request.workspaceId !== void 0) return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+				const registry = this.mcpServers(ctx);
+				await registry.setEnabled(request, settings);
+				return {
+					...registry.list(settings),
+					...target
+				};
+			});
+			return this.mcpServers().setEnabled(request);
+		}
+		/**
+		* Remove one MCP record and unmount its server.
+		* @param request - Stored record name and optional workspace file to edit; a string selects global records.
+		* @returns Refreshed MCP record projection.
+		*/
+		removeMcpServer(request) {
+			if (typeof request !== "string") this.assertTarget(request);
+			if (typeof request !== "string" && request.workspaceId !== void 0) return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+				const registry = this.mcpServers(ctx);
+				await registry.remove(request.name, settings);
+				return {
+					...registry.list(settings),
+					...target
+				};
+			});
+			return this.mcpServers().remove(typeof request === "string" ? request : request.name);
+		}
+		/**
+		* List the user's own hook records with their live state.
+		* @param request - Workspace to inspect; omission selects the user's global records.
+		* @returns Selected settings records with runtime status and the workspace target.
+		*/
+		listHookRecords(request) {
+			const target = request ?? {};
+			this.assertTarget(target);
+			if (target.workspaceId !== void 0) return this.workspaceTarget(target.workspaceId, target.layer).then(({ ctx, settings, target: selected }) => ({
+				...this.hookRecords(ctx).list(settings),
+				...selected
+			}));
+			return Promise.resolve(this.hookRecords().list());
+		}
+		/**
+		* Store one complete hook record definition and converge its bridge mount.
+		* @param request - Complete record definition and optional workspace file to edit.
+		* @returns Refreshed hook record projection.
+		*/
+		defineHookRecord(request) {
+			this.assertTarget(request);
+			if (request.workspaceId !== void 0) return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+				const registry = this.hookRecords(ctx);
+				await registry.define(request, settings);
+				return {
+					...registry.list(settings),
+					...target
+				};
+			});
+			return this.hookRecords().define(request);
+		}
+		/**
+		* Change one hook record's desired state without touching its definition.
+		* @param request - Target record, desired state, and optional workspace file to edit.
+		* @returns Refreshed hook record projection.
+		*/
+		setHookRecordEnabled(request) {
+			this.assertTarget(request);
+			if (request.workspaceId !== void 0) return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+				const registry = this.hookRecords(ctx);
+				await registry.setEnabled(request, settings);
+				return {
+					...registry.list(settings),
+					...target
+				};
+			});
+			return this.hookRecords().setEnabled(request);
+		}
+		/**
+		* Remove one hook record and unmount its bridge.
+		* @param request - Stored record name and optional workspace file to edit; a string selects global records.
+		* @returns Refreshed hook record projection.
+		*/
+		removeHookRecord(request) {
+			if (typeof request !== "string") this.assertTarget(request);
+			if (typeof request !== "string" && request.workspaceId !== void 0) return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+				const registry = this.hookRecords(ctx);
+				await registry.remove(request.name, settings);
+				return {
+					...registry.list(settings),
+					...target
+				};
+			});
+			return this.hookRecords().remove(typeof request === "string" ? request : request.name);
+		}
+		/** Reject a workspace file selector that cannot identify a workspace. */
+		assertTarget(target) {
+			if (target.workspaceId === void 0 && target.layer !== void 0) throw new Error("pluginInventory: layer requires workspaceId");
+		}
+		/** Resolve one workspace's runtime services and selected editable settings file. */
+		async workspaceTarget(workspaceId, layer = "local") {
+			const service = this.ctx.get("workspaceConfig");
+			if (service === void 0) throw new Error("pluginInventory: workspace configuration is unavailable");
+			const environment = await service.environmentFor(workspaceId);
+			const settings = await service.settingsFor(workspaceId, layer);
+			return {
+				ctx: environment.ctx,
+				presets: environment.presets,
+				settings,
+				target: {
+					workspaceId,
+					layer
+				}
+			};
+		}
+		importedPlugins() {
+			const runtime = this.ctx.get("importedPlugins");
+			if (runtime === void 0) throw new Error("pluginInventory: imported plugin runtime is unavailable");
+			return runtime;
+		}
+		/** The MCP record registry is optional in compositions without user MCP servers. */
+		mcpServers(ctx = this.ctx) {
+			const registry = ctx.get("mcpServers");
+			if (registry === void 0) throw new Error("pluginInventory: MCP server registry is unavailable");
+			return registry;
+		}
+		/** The hook record registry is optional in compositions without user hooks. */
+		hookRecords(ctx = this.ctx) {
+			const registry = ctx.get("hookRecords");
+			if (registry === void 0) throw new Error("pluginInventory: hook record registry is unavailable");
+			return registry;
+		}
+		/** Agent-preset ownership is optional in headless and non-roster compositions. */
+		agentPresets() {
+			return this.ctx.get("agentPresets");
+		}
+	};
+})();
+//#endregion
+export { PluginInventoryGateway, PluginInventoryGateway as default };