@clinebot/core 0.0.35 → 0.0.36

package/src/extensions/config/agent-config-loader.ts

@@ -43,12 +43,14 @@ export function resolveAgentsConfigDirPath(): string {
 	return resolveAgentsConfigDirPathFromShared();
 }
 
-export function resolveAgentConfigSearchPaths(): string[] {
-	// Documents path first, then settings path so settings location takes precedence.
-	return resolveAgentConfigSearchPathsFromShared();
+export function resolveAgentConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return resolveAgentConfigSearchPathsFromShared(workspacePath);
 }
 
 export interface CreateAgentConfigWatcherOptions {
+	workspacePath?: string;
 	directoryPathOrPaths?: string | ReadonlyArray<string>;
 	debounceMs?: number;
 	emitParseErrors?: boolean;
@@ -56,6 +58,7 @@ export interface CreateAgentConfigWatcherOptions {
 
 function toDirectoryPaths(
 	directoryPathOrPaths?: string | ReadonlyArray<string>,
+	workspacePath?: string,
 ): string[] {
 	if (Array.isArray(directoryPathOrPaths)) {
 		return [...directoryPathOrPaths];
@@ -63,15 +66,16 @@ function toDirectoryPaths(
 	if (typeof directoryPathOrPaths === "string") {
 		return [directoryPathOrPaths];
 	}
-	return resolveAgentConfigSearchPaths();
+	return resolveAgentConfigSearchPaths(workspacePath);
 }
 
 export function createAgentConfigDefinition(
 	directoryPathOrPaths?: string | ReadonlyArray<string>,
+	workspacePath?: string,
 ): UnifiedConfigDefinition<"agent", AgentYamlConfig> {
 	return {
 		type: "agent",
-		directories: toDirectoryPaths(directoryPathOrPaths),
+		directories: toDirectoryPaths(directoryPathOrPaths, workspacePath),
 		includeFile: (fileName) => isAgentConfigYamlFile(fileName),
 		parseFile: (context) => parseAgentConfigFromYaml(context.content),
 		resolveId: (config) => normalizeAgentConfigName(config.name),
@@ -82,7 +86,12 @@ export function createAgentConfigWatcher(
 	options?: CreateAgentConfigWatcherOptions,
 ): AgentConfigWatcher {
 	return new UnifiedConfigFileWatcher(
-		[createAgentConfigDefinition(options?.directoryPathOrPaths)],
+		[
+			createAgentConfigDefinition(
+				options?.directoryPathOrPaths,
+				options?.workspacePath,
+			),
+		],
 		{
 			debounceMs: options?.debounceMs,
 			emitParseErrors: options?.emitParseErrors,
@@ -92,9 +101,10 @@ export function createAgentConfigWatcher(
 
 export async function readAgentConfigsFromDisk(
 	directoryPathOrPaths?: string | ReadonlyArray<string>,
+	workspacePath?: string,
 ): Promise<Map<string, AgentYamlConfig>> {
 	const watcher = new UnifiedConfigFileWatcher([
-		createAgentConfigDefinition(directoryPathOrPaths),
+		createAgentConfigDefinition(directoryPathOrPaths, workspacePath),
 	]);
 	await watcher.refreshAll();
 	const snapshot = watcher.getSnapshot("agent");

package/src/extensions/config/runtime-commands.ts

@@ -1,3 +1,4 @@
+import { truncateSplit } from "@clinebot/shared";
 import type {
 	SkillConfig,
 	UserInstructionConfigWatcher,
@@ -10,6 +11,7 @@ export type AvailableRuntimeCommand = {
 	id: string;
 	name: string;
 	instructions: string;
+	description?: string;
 	kind: RuntimeCommandKind;
 };
 
@@ -32,6 +34,10 @@ function listCommandsForKind(
 			id,
 			name: record.item.name,
 			instructions: record.item.instructions,
+			description: truncateSplit(
+				record.item.description ?? record.item.instructions,
+				".",
+			),
 			kind,
 		}))
 		.sort((a, b) => a.name.localeCompare(b.name));

package/src/extensions/config/user-instruction-config-loader.ts

@@ -52,6 +52,7 @@ export interface RuleConfig {
 export interface WorkflowConfig {
 	name: string;
 	disabled?: boolean;
+	description?: string;
 	instructions: string;
 	frontmatter: Record<string, unknown>;
 }

package/src/extensions/context/agentic-compaction.ts

@@ -1,4 +1,3 @@
-import type * as LlmsProviders from "@clinebot/llms";
 import { createHandler } from "@clinebot/llms";
 import type { BasicLogger } from "@clinebot/shared";
 import type {
@@ -6,6 +5,7 @@ import type {
 	CoreCompactionResult,
 	CoreCompactionSummarizerConfig,
 } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
 import {
 	buildSummaryMessage,
 	buildSummaryRequest,
@@ -20,7 +20,7 @@ import {
 } from "./compaction-shared";
 
 async function generateSummary(options: {
-	providerConfig: LlmsProviders.ProviderConfig;
+	providerConfig: ProviderConfig;
 	request: string;
 	logger?: BasicLogger;
 }): Promise<string> {
@@ -48,7 +48,7 @@ async function generateSummary(options: {
 
 export async function runAgenticCompaction(options: {
 	context: CoreCompactionContext;
-	providerConfig: LlmsProviders.ProviderConfig;
+	providerConfig: ProviderConfig;
 	summarizer?: CoreCompactionSummarizerConfig;
 	preserveRecentTokens: number;
 	estimateMessageTokens: EstimateMessageTokens;

package/src/extensions/context/basic-compaction.ts

@@ -33,9 +33,9 @@ function sanitizeMessageForBasic(
 		return text ? { ...message, content: text } : undefined;
 	}
 
-	// Preserve array structure: keep only text blocks with non-empty content.
+	// Preserve multimodal structure: trim text blocks, keep non-text blocks intact.
 	const kept = message.content.filter(
-		(block) => block.type === "text" && block.text.trim(),
+		(block) => block.type !== "text" || block.text.trim(),
 	);
 	if (kept.length === 0) {
 		return undefined;

package/src/extensions/context/compaction-shared.ts

@@ -1,9 +1,10 @@
-import type * as LlmsProviders from "@clinebot/llms";
+import type { ToolResultContent } from "@clinebot/llms";
 import type { MessageWithMetadata } from "@clinebot/shared";
 import type {
 	CoreCompactionContext,
 	CoreCompactionSummarizerConfig,
 } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
 
 export const DEFAULT_CONTEXT_WINDOW_TOKENS = 200_000;
 export const DEFAULT_THRESHOLD_RATIO = 0.95;
@@ -41,7 +42,7 @@ export function truncateText(text: string, limit: number): string {
 }
 
 export function flattenToolResultContent(
-	content: LlmsProviders.ToolResultContent["content"],
+	content: ToolResultContent["content"],
 ): string {
 	if (typeof content === "string") {
 		return truncateText(content, TOOL_RESULT_CHAR_LIMIT);
@@ -404,9 +405,9 @@ Edited: ${options.fileOps.modifiedFiles.join(", ") || "none"}`,
 }
 
 export function resolveSummarizerConfig(options: {
-	activeProviderConfig: LlmsProviders.ProviderConfig;
+	activeProviderConfig: ProviderConfig;
 	summarizer?: CoreCompactionSummarizerConfig;
-}): LlmsProviders.ProviderConfig {
+}): ProviderConfig {
 	const summarizer = options.summarizer;
 	if (!summarizer) {
 		return {

package/src/extensions/context/compaction.ts

@@ -1,4 +1,3 @@
-import type * as LlmsProviders from "@clinebot/llms";
 import type {
 	CoreCompactionConfig,
 	CoreCompactionContext,
@@ -6,6 +5,7 @@ import type {
 	CoreCompactionStrategy,
 	CoreSessionConfig,
 } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
 import { runAgenticCompaction } from "./agentic-compaction";
 import { runBasicCompaction } from "./basic-compaction";
 import {
@@ -41,7 +41,7 @@ type EstimateMessageTokens = ReturnType<typeof createTokenEstimator>;
 
 type BuiltinCompactionStrategyOptions = {
 	context: CoreCompactionContext;
-	providerConfig: LlmsProviders.ProviderConfig;
+	providerConfig: ProviderConfig;
 	compaction: CoreCompactionConfig | undefined;
 	estimateMessageTokens: EstimateMessageTokens;
 	logger: Pick<CoreSessionConfig, "logger">["logger"];
@@ -129,7 +129,7 @@ export function createContextCompactionPrepareTurn(
 		({
 			providerId: config.providerId,
 			modelId: config.modelId,
-		} as LlmsProviders.ProviderConfig);
+		} as ProviderConfig);
 	const estimateMessageTokens = createTokenEstimator();
 	const strategy = userCompaction?.strategy ?? "basic";
 	const runBuiltinStrategy = BUILTIN_COMPACTION_STRATEGIES[strategy];

package/src/extensions/plugin/plugin-config-loader.ts

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import type { AgentConfig } from "@clinebot/shared";
+import type { AgentConfig, WorkspaceInfo } from "@clinebot/shared";
 import {
 	discoverPluginModulePaths as discoverPluginModulePathsFromShared,
 	resolveConfiguredPluginModulePaths,
@@ -8,6 +8,7 @@ import {
 import type { PluginLoadDiagnostics } from "./plugin-load-report";
 import { loadAgentPluginsFromPathsWithDiagnostics } from "./plugin-loader";
 import { loadSandboxedPlugins } from "./plugin-sandbox";
+import type { PluginTargeting } from "./plugin-targeting";
 
 type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
 
@@ -54,13 +55,20 @@ export function resolveAgentPluginPaths(
 }
 
 export interface ResolveAndLoadAgentPluginsOptions
-	extends ResolveAgentPluginPathsOptions {
+	extends ResolveAgentPluginPathsOptions,
+		PluginTargeting {
 	mode?: "sandbox" | "in_process";
 	exportName?: string;
 	importTimeoutMs?: number;
 	hookTimeoutMs?: number;
 	contributionTimeoutMs?: number;
 	onEvent?: (event: { name: string; payload?: unknown }) => void;
+	/**
+	 * Structured workspace and git metadata. Forwarded to sandboxed plugins
+	 * via PluginSetupCtx.workspaceInfo and made available to in-process plugins
+	 * in the extension context.
+	 */
+	workspaceInfo?: WorkspaceInfo;
 }
 
 export async function resolveAndLoadAgentPlugins(
@@ -80,6 +88,9 @@ export async function resolveAndLoadAgentPlugins(
 		const report = await loadAgentPluginsFromPathsWithDiagnostics(paths, {
 			cwd: options.cwd,
 			exportName: options.exportName,
+			providerId: options.providerId,
+			modelId: options.modelId,
+			workspaceInfo: options.workspaceInfo,
 		});
 		return {
 			extensions: report.plugins,
@@ -95,6 +106,10 @@ export async function resolveAndLoadAgentPlugins(
 		hookTimeoutMs: options.hookTimeoutMs,
 		contributionTimeoutMs: options.contributionTimeoutMs,
 		onEvent: options.onEvent,
+		providerId: options.providerId,
+		modelId: options.modelId,
+		cwd: options.cwd,
+		workspaceInfo: options.workspaceInfo,
 	});
 	return {
 		extensions: sandboxed.extensions ?? [],

package/src/extensions/plugin/plugin-loader.ts

@@ -1,10 +1,15 @@
 import { resolve } from "node:path";
-import type { AgentConfig } from "@clinebot/shared";
+import type { AgentConfig, PluginSetupContext } from "@clinebot/shared";
+import { normalizePluginManifest } from "@clinebot/shared";
 import type {
 	PluginInitializationFailure,
 	PluginInitializationWarning,
 } from "./plugin-load-report";
 import { importPluginModule } from "./plugin-module-import";
+import {
+	matchesPluginManifestTargeting,
+	type PluginTargeting,
+} from "./plugin-targeting";
 
 type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
 type PluginLike = {
@@ -12,6 +17,8 @@ type PluginLike = {
 	manifest: {
 		capabilities: string[];
 		hookStages?: string[];
+		providerIds?: string[];
+		modelIds?: string[];
 	};
 };
 
@@ -19,6 +26,7 @@ export interface LoadAgentPluginFromPathOptions {
 	exportName?: string;
 	cwd?: string;
 	useCache?: boolean;
+	workspaceInfo?: PluginSetupContext["workspaceInfo"];
 }
 
 function isObject(value: unknown): value is Record<string, unknown> {
@@ -58,6 +66,22 @@ function validatePluginManifest(
 			`Invalid plugin module at ${absolutePath}: manifest.hookStages must be a string array when provided`,
 		);
 	}
+	if (
+		Object.hasOwn(plugin.manifest, "providerIds") &&
+		!hasValidStringArray(plugin.manifest.providerIds)
+	) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: manifest.providerIds must be a string array when provided`,
+		);
+	}
+	if (
+		Object.hasOwn(plugin.manifest, "modelIds") &&
+		!hasValidStringArray(plugin.manifest.modelIds)
+	) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: manifest.modelIds must be a string array when provided`,
+		);
+	}
 }
 
 function validatePluginExport(
@@ -95,12 +119,29 @@ export async function loadAgentPluginFromPath(
 		moduleExports[exportName]) as unknown;
 
 	validatePluginExport(plugin, absolutePath);
-	return plugin as AgentPlugin;
+	const pluginTyped = plugin as AgentPlugin;
+	const originalSetup = pluginTyped.setup;
+
+	// Wrap setup to inject workspace context
+	const setupWithContext: AgentPlugin["setup"] = originalSetup
+		? (api, _ctx) => {
+				const ctx = {
+					workspaceInfo: options.workspaceInfo,
+				};
+				return originalSetup(api, ctx);
+			}
+		: undefined;
+
+	return {
+		...pluginTyped,
+		manifest: normalizePluginManifest(pluginTyped.manifest),
+		setup: setupWithContext,
+	};
 }
 
 export async function loadAgentPluginsFromPaths(
 	pluginPaths: string[],
-	options: LoadAgentPluginFromPathOptions = {},
+	options: LoadAgentPluginFromPathOptions & PluginTargeting = {},
 ): Promise<AgentPlugin[]> {
 	const report = await loadAgentPluginsFromPathsWithDiagnostics(
 		pluginPaths,
@@ -111,7 +152,7 @@ export async function loadAgentPluginsFromPaths(
 
 export async function loadAgentPluginsFromPathsWithDiagnostics(
 	pluginPaths: string[],
-	options: LoadAgentPluginFromPathOptions = {},
+	options: LoadAgentPluginFromPathOptions & PluginTargeting = {},
 ): Promise<{
 	plugins: AgentPlugin[];
 	failures: PluginInitializationFailure[];
@@ -128,6 +169,9 @@ export async function loadAgentPluginsFromPathsWithDiagnostics(
 	for (const pluginPath of pluginPaths) {
 		try {
 			const plugin = await loadAgentPluginFromPath(pluginPath, options);
+			if (!matchesPluginManifestTargeting(plugin.manifest, options)) {
+				continue;
+			}
 			const existing = loadedByName.get(plugin.name);
 			if (existing) {
 				warnings.push({

package/src/extensions/plugin/plugin-module-import.ts

@@ -26,8 +26,6 @@ function collectWorkspaceAliases(root: string): Record<string, string> {
 		"@clinebot/agents": resolve(root, "packages/agents/src/index.ts"),
 		"@clinebot/core": resolve(root, "packages/core/src/index.ts"),
 		"@clinebot/llms": resolve(root, "packages/llms/src/index.ts"),
-		"@clinebot/rpc": resolve(root, "packages/rpc/src/index.ts"),
-		"@clinebot/scheduler": resolve(root, "packages/scheduler/src/index.ts"),
 		"@clinebot/shared": resolve(root, "packages/shared/src/index.ts"),
 		"@clinebot/shared/storage": resolve(
 			root,

package/src/extensions/plugin/plugin-sandbox-bootstrap.ts

@@ -4,13 +4,18 @@
  * This file runs inside an isolated Node.js child process spawned by
  * {@link SubprocessSandbox}. It receives RPC calls over IPC and dynamically
  * imports plugin modules, wiring up their contributions (tools, commands,
- * shortcuts, flags, renderers, providers) and lifecycle hooks.
+ * message builders, providers) and lifecycle hooks.
  *
  * Because it executes in a separate process it must stay bundle-safe and only
  * depend on local helpers that can be inlined into the sandbox build.
  */
 
+import { normalizePluginManifest, type PluginManifest } from "@clinebot/shared";
 import { importPluginModule } from "./plugin-module-import";
+import {
+	matchesPluginManifestTargeting,
+	type PluginTargeting,
+} from "./plugin-targeting";
 
 // ---------------------------------------------------------------------------
 // Types (intentionally minimal – mirrors only what the RPC protocol needs)
@@ -31,18 +36,6 @@ interface PluginCommand {
 	handler?: (input: string) => Promise<string>;
 }
 
-interface PluginShortcut {
-	name: string;
-	value: string;
-	description?: string;
-}
-
-interface PluginFlag {
-	name: string;
-	description?: string;
-	defaultValue?: boolean | string | number;
-}
-
 interface PluginMessageBuilder {
 	name: string;
 	build: (message: unknown[]) => unknown[]; // Message[]
@@ -57,16 +50,18 @@ interface PluginProvider {
 interface PluginApi {
 	registerTool(tool: PluginTool): void;
 	registerCommand(command: PluginCommand): void;
-	registerShortcut(shortcut: PluginShortcut): void;
-	registerFlag(flag: PluginFlag): void;
 	registerMessageBuilder(builder: PluginMessageBuilder): void;
 	registerProvider(provider: PluginProvider): void;
 }
 
+interface PluginSetupCtx {
+	workspaceInfo?: unknown;
+}
+
 interface PluginModule {
 	name: string;
-	manifest: Record<string, unknown>;
-	setup?: (api: PluginApi) => void | Promise<void>;
+	manifest: PluginManifest;
+	setup?: (api: PluginApi, ctx: PluginSetupCtx) => void | Promise<void>;
 	[hookName: string]: unknown;
 }
 
@@ -86,14 +81,14 @@ interface PluginDescriptor {
 	pluginId: string;
 	pluginPath: string;
 	name: string;
-	manifest: Record<string, unknown>;
+	manifest: PluginManifest;
 	contributions: {
 		tools: ContributionDescriptor[];
 		commands: ContributionDescriptor[];
-		shortcuts: ContributionDescriptor[];
-		flags: ContributionDescriptor[];
 		messageBuilders: ContributionDescriptor[];
 		providers: ContributionDescriptor[];
+		shortcuts?: ContributionDescriptor[];
+		flags?: ContributionDescriptor[];
 	};
 }
 
@@ -132,6 +127,12 @@ function isObject(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null;
 }
 
+function hasValidStringArray(value: unknown): value is string[] {
+	return (
+		Array.isArray(value) && value.every((entry) => typeof entry === "string")
+	);
+}
+
 function assertValidPluginModule(
 	plugin: unknown,
 	pluginPath: string,
@@ -145,6 +146,29 @@ function assertValidPluginModule(
 	if (!isObject(plugin.manifest)) {
 		throw new Error(`Invalid plugin manifest: ${pluginPath}`);
 	}
+	if (
+		Object.hasOwn(plugin.manifest, "providerIds") &&
+		!hasValidStringArray(plugin.manifest.providerIds)
+	) {
+		throw new Error(`Invalid plugin manifest.providerIds: ${pluginPath}`);
+	}
+	if (
+		Object.hasOwn(plugin.manifest, "modelIds") &&
+		!hasValidStringArray(plugin.manifest.modelIds)
+	) {
+		throw new Error(`Invalid plugin manifest.modelIds: ${pluginPath}`);
+	}
+}
+
+function assertValidPluginSetupCtx(
+	ctx: unknown,
+): asserts ctx is PluginSetupCtx {
+	if (!isObject(ctx)) {
+		throw new Error("Plugin setup context must be an object");
+	}
+	if (ctx.workspaceInfo !== undefined && !isObject(ctx.workspaceInfo)) {
+		throw new Error("Plugin setup context workspaceInfo must be an object");
+	}
 }
 
 // ---------------------------------------------------------------------------
@@ -183,6 +207,16 @@ function emitEvent(name: string, payload?: unknown): void {
 // Expose event emitter to plugins.
 (globalThis as Record<string, unknown>).__clinePluginHost = { emitEvent };
 
+/**
+ * Session workspace env — populated by `initialize()` and available to any
+ * plugin code that executes before the setup hook, or cannot use hook context.
+ * Prefer using PluginSetupCtx from the setup function when possible.
+ */
+(globalThis as Record<string, unknown>).__clineSessionEnv = {
+	cwd: undefined as string | undefined,
+	workspaceInfo: undefined as unknown,
+};
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -214,16 +248,44 @@ function getPlugin(pluginId: string): PluginState {
 async function initialize(args: {
 	pluginPaths?: string[];
 	exportName?: string;
+	providerId?: string;
+	modelId?: string;
+	cwd?: string;
+	workspaceInfo?: unknown;
 }): Promise<InitializeResult> {
 	pluginState.clear();
 	pluginCounter = 0;
 	contributionCounters.clear();
 
+	// Apply the session's working directory so that process.cwd() and relative
+	// path resolution inside plugins reflect the correct workspace, not the
+	// host process's cwd (which may differ when --cwd was used without calling
+	// process.chdir() on the host side).
+	if (args.cwd) {
+		try {
+			process.chdir(args.cwd);
+		} catch {
+			// Ignore — best-effort; path may not exist in unusual environments.
+		}
+	}
+
+	// Keep the global escape-hatch in sync with the active session.
+	const sessionEnv = (globalThis as Record<string, unknown>)
+		.__clineSessionEnv as Record<string, unknown>;
+	if (sessionEnv) {
+		sessionEnv.cwd = args.cwd;
+		sessionEnv.workspaceInfo = args.workspaceInfo;
+	}
+
 	const descriptors: PluginDescriptor[] = [];
 	const failures: PluginInitializationFailure[] = [];
 	const warnings: PluginInitializationWarning[] = [];
 	const exportName = args.exportName || "plugin";
 	const pluginIndexByName = new Map<string, number>();
+	const targeting: PluginTargeting = {
+		providerId: args.providerId,
+		modelId: args.modelId,
+	};
 
 	for (const pluginPath of args.pluginPaths || []) {
 		let plugin: PluginModule | undefined;
@@ -232,15 +294,19 @@ async function initialize(args: {
 			plugin = (moduleExports.default ??
 				moduleExports[exportName]) as unknown as PluginModule;
 			assertValidPluginModule(plugin, pluginPath);
+			plugin.manifest = normalizePluginManifest(plugin.manifest);
+			if (!matchesPluginManifestTargeting(plugin.manifest, targeting)) {
+				continue;
+			}
 
 			const pluginId = `plugin_${++pluginCounter}`;
 			const contributions: PluginDescriptor["contributions"] = {
 				tools: [],
 				commands: [],
-				shortcuts: [],
-				flags: [],
 				messageBuilders: [],
 				providers: [],
+				shortcuts: [],
+				flags: [],
 			};
 			const handlers: PluginState["handlers"] = {
 				tools: new Map(),
@@ -272,22 +338,6 @@ async function initialize(args: {
 						description: command.description,
 					});
 				},
-				registerShortcut: (shortcut) => {
-					contributions.shortcuts.push({
-						id: makeId(pluginId, "shortcut"),
-						name: shortcut.name,
-						value: shortcut.value,
-						description: shortcut.description,
-					});
-				},
-				registerFlag: (flag) => {
-					contributions.flags.push({
-						id: makeId(pluginId, "flag"),
-						name: flag.name,
-						description: flag.description,
-						defaultValue: flag.defaultValue,
-					});
-				},
 				registerMessageBuilder: (builder) => {
 					const id = makeId(pluginId, "builder");
 					handlers.messageBuilders.set(id, builder.build);
@@ -305,7 +355,11 @@ async function initialize(args: {
 
 			if (typeof plugin.setup === "function") {
 				try {
-					await plugin.setup(api);
+					const setupCtx = {
+						workspaceInfo: args.workspaceInfo,
+					};
+					assertValidPluginSetupCtx(setupCtx);
+					await plugin.setup(api, setupCtx);
 				} catch (error) {
 					failures.push({
 						pluginPath,