@gajae-code/coding-agent 0.16.7 → 0.17.1

package/src/discovery/index.ts

@@ -59,6 +59,7 @@ export {
 	listCapabilities,
 	// Loading API
 	loadCapability,
+	loadCapabilityForHome,
 	releaseSettingsScope,
 	// Cache management
 	reset,

package/src/discovery/mcp-json.ts

@@ -11,10 +11,10 @@ import * as fsPromises from "node:fs/promises";
 import * as path from "node:path";
 import { logger, tryParseJson } from "@gajae-code/utils";
 import { registerProvider } from "../capability";
-import { readFile } from "../capability/fs";
+import { type ReadFileOptions, readFile } from "../capability/fs";
 import { type MCPServer, mcpCapability } from "../capability/mcp";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
-import { createSourceMeta, expandEnvVarsDeep } from "./helpers";
+import { canonicalizePathWithinHome, createSourceMeta, expandEnvVarsDeep, getReadOptions } from "./helpers";
 
 const PROVIDER_ID = "mcp-json";
 const DISPLAY_NAME = "MCP Config";
@@ -440,18 +440,40 @@ async function readExactMCPConfigFile(filePath: string): Promise<string | null>
 export async function loadMCPJsonFile(
 	filePath: string,
 	level: "user" | "project",
-	options?: { quiet?: boolean; useCache?: boolean },
+	options?: { quiet?: boolean; useCache?: boolean; readOptions?: ReadFileOptions },
 ): Promise<MCPJsonLoadResult> {
 	const warnings: string[] = [];
 	const items: MCPServer[] = [];
+	let sourcePath = filePath;
+	if (options?.readOptions?.isolatedHome) {
+		if (typeof options.readOptions.home !== "string") {
+			if (options.quiet) warnings.push("MCP configuration unavailable");
+			return { items, warnings, disabledServers: [] };
+		}
+		const authorizedPath = await canonicalizePathWithinHome(
+			{
+				home: options.readOptions.home,
+				isolatedHome: true,
+				userAgentDir: options.readOptions.userAgentDir,
+			},
+			filePath,
+			undefined,
+			options.readOptions.scope ?? "project",
+		);
+		if (!authorizedPath) {
+			if (options.quiet) warnings.push("MCP configuration unavailable");
+			return { items, warnings, disabledServers: [] };
+		}
+		sourcePath = authorizedPath;
+	}
 
 	const content = options?.quiet
-		? await readExactMCPConfigFile(filePath)
+		? options.readOptions?.isolatedHome
+			? await readFile(sourcePath, { ...options.readOptions, bypassCache: true })
+			: await readExactMCPConfigFile(sourcePath)
 		: options?.useCache === false
-			? await Bun.file(filePath)
-					.text()
-					.catch(() => null)
-			: await readFile(filePath);
+			? await readFile(filePath, { ...options.readOptions, bypassCache: true })
+			: await readFile(filePath, options?.readOptions);
 	if (content === null) {
 		if (options?.quiet) warnings.push("MCP configuration unavailable");
 		return { items, warnings, disabledServers: [] };
@@ -474,7 +496,7 @@ export async function loadMCPJsonFile(
 	} else {
 		validConfig = config as MCPConfigFile;
 	}
-	const source = createSourceMeta(PROVIDER_ID, filePath, level);
+	const source = createSourceMeta(PROVIDER_ID, sourcePath, level);
 	items.push(...transformMCPConfig(validConfig, source, options?.quiet));
 
 	return {
@@ -490,7 +512,11 @@ export async function loadMCPJsonFile(
 async function load(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
 	const filenames = ["mcp.json", ".mcp.json"];
 	const results = await Promise.all(
-		filenames.map(filename => loadMCPJsonFile(path.join(ctx.cwd, filename), "project")),
+		filenames.map(filename =>
+			loadMCPJsonFile(path.join(ctx.cwd, filename), "project", {
+				readOptions: getReadOptions(ctx, "project"),
+			}),
+		),
 	);
 
 	const allItems = results.flatMap(r => r.items);

package/src/discovery/opencode.ts

@@ -32,9 +32,11 @@ import type { Settings as RuntimeSettings } from "../config/settings";
 
 import {
 	buildExtensionModuleItems,
+	canonicalizePathWithinHome,
 	createSourceMeta,
 	discoverExtensionModulePaths,
 	getProjectPath,
+	getReadOptions,
 	getUserPath,
 	loadFilesFromDir,
 	scanSkillsFromDir,
@@ -53,9 +55,12 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 	const warnings: string[] = [];
 
 	// User-level only: ~/.config/opencode/AGENTS.md
-	const userAgentsMd = getUserPath(ctx, "opencode", "AGENTS.md");
+	const rawUserAgentsMd = getUserPath(ctx, "opencode", "AGENTS.md");
+	const userAgentsMd = rawUserAgentsMd
+		? await canonicalizePathWithinHome(ctx, rawUserAgentsMd, undefined, "user")
+		: null;
 	if (userAgentsMd) {
-		const content = await readFile(userAgentsMd);
+		const content = await readFile(userAgentsMd, getReadOptions(ctx, "user"));
 		if (content) {
 			items.push({
 				path: userAgentsMd,
@@ -115,8 +120,10 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 	const projectPluginsDir = getProjectPath(ctx, "opencode", "plugins");
 
 	const [userPaths, projectPaths] = await Promise.all([
-		userPluginsDir ? discoverExtensionModulePaths(ctx, userPluginsDir) : Promise.resolve([]),
-		projectPluginsDir ? discoverExtensionModulePaths(ctx, projectPluginsDir) : Promise.resolve([]),
+		userPluginsDir ? discoverExtensionModulePaths(ctx, userPluginsDir, { scope: "user" }) : Promise.resolve([]),
+		projectPluginsDir
+			? discoverExtensionModulePaths(ctx, projectPluginsDir, { scope: "project" })
+			: Promise.resolve([]),
 	]);
 
 	const items = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
@@ -201,9 +208,12 @@ async function loadSettings(ctx: LoadContext): Promise<LoadResult<SettingsCapabi
 	const warnings: string[] = [];
 
 	// User-level: ~/.config/opencode/opencode.json
-	const userConfigPath = getUserPath(ctx, "opencode", "opencode.json");
+	const rawUserConfigPath = getUserPath(ctx, "opencode", "opencode.json");
+	const userConfigPath = rawUserConfigPath
+		? await canonicalizePathWithinHome(ctx, rawUserConfigPath, undefined, "user")
+		: null;
 	if (userConfigPath) {
-		const content = await readFile(userConfigPath);
+		const content = await readFile(userConfigPath, getReadOptions(ctx, "user"));
 		if (content) {
 			const parsed = tryParseJson<Record<string, unknown>>(content);
 			if (parsed) {
@@ -220,19 +230,26 @@ async function loadSettings(ctx: LoadContext): Promise<LoadResult<SettingsCapabi
 	}
 
 	// Project-level: opencode.json in project root
-	const projectConfigPath = path.join(ctx.cwd, "opencode.json");
-	const content = await readFile(projectConfigPath);
-	if (content) {
-		const parsed = tryParseJson<Record<string, unknown>>(content);
-		if (parsed) {
-			items.push({
-				path: projectConfigPath,
-				data: parsed,
-				level: "project",
-				_source: createSourceMeta(PROVIDER_ID, projectConfigPath, "project"),
-			});
-		} else {
-			warnings.push(`Invalid JSON in ${projectConfigPath}`);
+	const projectConfigPath = await canonicalizePathWithinHome(
+		ctx,
+		path.join(ctx.cwd, "opencode.json"),
+		undefined,
+		"project",
+	);
+	if (projectConfigPath) {
+		const content = await readFile(projectConfigPath, getReadOptions(ctx, "project"));
+		if (content) {
+			const parsed = tryParseJson<Record<string, unknown>>(content);
+			if (parsed) {
+				items.push({
+					path: projectConfigPath,
+					data: parsed,
+					level: "project",
+					_source: createSourceMeta(PROVIDER_ID, projectConfigPath, "project"),
+				});
+			} else {
+				warnings.push(`Invalid JSON in ${projectConfigPath}`);
+			}
 		}
 	}
 

package/src/discovery/ssh.ts

@@ -12,7 +12,7 @@ import { type SSHHost, sshCapability } from "../capability/ssh";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 import { validateSshDestination } from "../ssh/utils";
 import { expandTilde } from "../tools/path-utils";
-import { createSourceMeta, expandEnvVarsDeep } from "./helpers";
+import { canonicalizePathWithinHome, createSourceMeta, expandEnvVarsDeep, getReadOptions } from "./helpers";
 
 const PROVIDER_ID = "ssh-json";
 const DISPLAY_NAME = "SSH Config";
@@ -102,29 +102,32 @@ async function loadSshJsonFile(
 ): Promise<LoadResult<SSHHost>> {
 	const items: SSHHost[] = [];
 	const warnings: string[] = [];
-	const content = await readFile(filePath);
+	const scope = level === "user" ? "native" : "project";
+	const canonicalPath = await canonicalizePathWithinHome(ctx, filePath, undefined, scope);
+	if (!canonicalPath) return { items, warnings };
+	const content = await readFile(canonicalPath, getReadOptions(ctx, scope));
 	if (content === null) {
 		return { items, warnings };
 	}
 	const parsed = tryParseJson<SSHConfigFile>(content);
 	if (!parsed) {
-		warnings.push(`Failed to parse JSON in ${filePath}`);
+		warnings.push(`Failed to parse JSON in ${canonicalPath}`);
 		return { items, warnings };
 	}
 	const config = expandEnvVarsDeep(parsed);
 	if (!config.hosts || typeof config.hosts !== "object") {
-		warnings.push(`Missing hosts in ${filePath}`);
+		warnings.push(`Missing hosts in ${canonicalPath}`);
 		return { items, warnings };
 	}
 
-	const source = createSourceMeta(PROVIDER_ID, filePath, level);
+	const source = createSourceMeta(PROVIDER_ID, canonicalPath, level);
 	for (const [name, rawHost] of Object.entries(config.hosts)) {
 		if (!name.trim()) {
-			warnings.push(`Invalid SSH host name in ${filePath}`);
+			warnings.push(`Invalid SSH host name in ${canonicalPath}`);
 			continue;
 		}
 		if (!rawHost || typeof rawHost !== "object") {
-			warnings.push(`Invalid host entry in ${filePath}: ${name}`);
+			warnings.push(`Invalid host entry in ${canonicalPath}: ${name}`);
 			continue;
 		}
 		const host = normalizeHost(name, rawHost, source, ctx.home, warnings);
@@ -139,7 +142,7 @@ async function loadSshJsonFile(
 async function load(ctx: LoadContext): Promise<LoadResult<SSHHost>> {
 	const candidateSources: Array<{ path: string; level: "user" | "project" }> = [
 		{ path: getSSHConfigPath("project", ctx.cwd), level: "project" },
-		{ path: getSSHConfigPath("user", ctx.cwd), level: "user" },
+		{ path: getSSHConfigPath("user", ctx.cwd, ctx.userAgentDir), level: "user" },
 		{ path: path.join(ctx.cwd, "ssh.json"), level: "project" },
 		{ path: path.join(ctx.cwd, ".ssh.json"), level: "project" },
 	];

package/src/discovery/windsurf.ts

@@ -17,7 +17,15 @@ import { registerProvider } from "../capability";
 import { readFile } from "../capability/fs";
 import { type Rule, ruleCapability } from "../capability/rule";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { buildRuleFromMarkdown, createSourceMeta, getProjectPath, getUserPath, loadFilesFromDir } from "./helpers";
+import {
+	buildRuleFromMarkdown,
+	canonicalizePathWithinHome,
+	createSourceMeta,
+	getProjectPath,
+	getReadOptions,
+	getUserPath,
+	loadFilesFromDir,
+} from "./helpers";
 
 const PROVIDER_ID = "windsurf";
 const DISPLAY_NAME = "Windsurf";
@@ -32,9 +40,10 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	const warnings: string[] = [];
 
 	// User-level: ~/.codeium/windsurf/memories/global_rules.md
-	const userPath = getUserPath(ctx, "windsurf", "memories/global_rules.md");
+	const rawUserPath = getUserPath(ctx, "windsurf", "memories/global_rules.md");
+	const userPath = rawUserPath ? await canonicalizePathWithinHome(ctx, rawUserPath, undefined, "user") : null;
 	if (userPath) {
-		const content = await readFile(userPath);
+		const content = await readFile(userPath, getReadOptions(ctx, "user"));
 		if (content) {
 			const source = createSourceMeta(PROVIDER_ID, userPath, "user");
 			items.push(buildRuleFromMarkdown("global_rules.md", content, userPath, source, { ruleName: "global_rules" }));

package/src/exec/bash-executor.ts

@@ -533,6 +533,10 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			!abortPromise
 		) {
 			abortPromise = activeShell.abort();
+			// Cancellation owns this acknowledgement immediately: the run can settle
+			// before cleanup reaches it, and worker close can reject both promises.
+			// Keep the original promise for cleanup without an unobserved window.
+			void abortPromise.catch(() => undefined);
 		}
 	};
 	const abortDeferred = Promise.withResolvers<"abort">();
@@ -549,9 +553,6 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			),
 			Bun.sleep(CANCEL_CLEANUP_WAIT_MS).then(() => false),
 		]);
-		if (abortPromise) {
-			await Promise.race([abortPromise.catch(() => undefined), Bun.sleep(CANCEL_CLEANUP_WAIT_MS)]);
-		}
 		return settled;
 	};
 	if (userSignal) {
@@ -797,6 +798,12 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			const disposePromise = oneShotShell.close();
 			await Promise.race([disposePromise.catch(() => undefined), Bun.sleep(CANCEL_CLEANUP_WAIT_MS)]);
 		}
+		// Also join cancellation requested after run settlement or on a path that
+		// skipped run cleanup. Close first so a pending acknowledgement cannot
+		// hold a one-shot worker open.
+		if (abortPromise) {
+			await Promise.race([abortPromise.catch(() => undefined), Bun.sleep(CANCEL_CLEANUP_WAIT_MS)]);
+		}
 	}
 }
 

package/src/exec/isolated-shell.ts

@@ -153,8 +153,16 @@ export class IsolatedShell {
 			}
 			this.#pending.set(id, pending);
 			const { signal: _signal, ...workerOptions } = options;
+			try {
+				this.#send({ type: "run", token: this.#protocolToken, id, options: workerOptions });
+			} catch (error) {
+				// A failed send has no protocol response owner. Do not leave its
+				// unobserved deferred for close() to reject later.
+				this.#pending.delete(id);
+				pending.removeAbortListener?.();
+				throw error;
+			}
 			if (options.signal instanceof AbortSignal) this.#dispatchedRunSignals.add(options.signal);
-			this.#send({ type: "run", token: this.#protocolToken, id, options: workerOptions });
 			return await deferred.promise;
 		} finally {
 			if (options.signal instanceof AbortSignal) this.#activeRunSignals.delete(options.signal);
@@ -193,7 +201,12 @@ export class IsolatedShell {
 		const id = this.#nextId++;
 		const deferred = Promise.withResolvers<void>();
 		this.#pending.set(id, { kind: "void", resolve: deferred.resolve, reject: deferred.reject });
-		this.#send({ type, token: this.#protocolToken, id });
+		try {
+			this.#send({ type, token: this.#protocolToken, id });
+		} catch (error) {
+			this.#pending.delete(id);
+			throw error;
+		}
 		await deferred.promise;
 	}
 

package/src/extensibility/extensions/loader.ts

@@ -7,9 +7,10 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@gajae-code/agent-core";
 import type { ImageContent, Model, TextContent, Tool, UsageReport } from "@gajae-code/ai/core";
 import type { KeyId } from "@gajae-code/tui";
-import { hasFsCode, isEacces, isEnoent, logger } from "@gajae-code/utils";
+import { hasFsCode, isEacces, isEnoent, logger, safeErrorDescription } from "@gajae-code/utils";
 import * as Zod from "zod/v4";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
+import type { Settings } from "../../config/settings";
 import { loadCapability } from "../../discovery";
 import { getExtensionNameFromPath } from "../../discovery/helpers";
 import type { ExecOptions } from "../../exec/exec";
@@ -511,9 +512,9 @@ async function loadExtension(
 	eventBus: EventBus,
 	runtime: IExtensionRuntime,
 ): Promise<{ extension: Extension | null; error: string | null }> {
-	const resolvedPath = resolvePath(extensionPath, cwd);
 	let activation: ExtensionActivationScope | undefined;
 	try {
+		const resolvedPath = resolvePath(extensionPath, cwd);
 		const module = (await loadLegacyPiModule(resolvedPath)) as LoadedExtensionModule;
 		const factory = getExtensionFactory(module);
 
@@ -540,8 +541,7 @@ async function loadExtension(
 		return { extension, error: null };
 	} catch (err) {
 		activation?.rollback();
-		const message = err instanceof Error ? err.message : String(err);
-		return { extension: null, error: `Failed to load extension: ${message}` };
+		return { extension: null, error: `Failed to load extension: ${safeErrorDescription(err)}` };
 	}
 }
 
@@ -588,7 +588,7 @@ export async function loadExtensions(paths: string[], cwd: string, eventBus?: Ev
 		const { extension, error } = await loadExtension(extPath, cwd, resolvedEventBus, runtime);
 
 		if (error) {
-			errors.push({ path: extPath, error });
+			errors.push({ path: safeErrorDescription(extPath), error });
 			continue;
 		}
 
@@ -622,7 +622,7 @@ async function readExtensionManifest(packageJsonPath: string): Promise<Extension
 		if (isEnoent(error) || isEacces(error) || hasFsCode(error, "EPERM")) {
 			return null;
 		}
-		logger.warn("Failed to read extension manifest", { path: packageJsonPath, error: String(error) });
+		logger.warn("Failed to read extension manifest", { path: packageJsonPath, error: safeErrorDescription(error) });
 		return null;
 	}
 }
@@ -705,7 +705,7 @@ async function discoverExtensionsInDir(dir: string): Promise<string[]> {
 		entries = await fs.readdir(dir, { withFileTypes: true });
 	} catch (err) {
 		if (isEnoent(err)) return [];
-		logger.warn("Failed to discover extensions in directory", { path: dir, error: String(err) });
+		logger.warn("Failed to discover extensions in directory", { path: dir, error: safeErrorDescription(err) });
 		return [];
 	}
 	entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
@@ -729,6 +729,27 @@ async function discoverExtensionsInDir(dir: string): Promise<string[]> {
 	return discovered;
 }
 
+/**
+ * Session-scoped discovery inputs.
+ *
+ * A session's selected agent directory is not necessarily the process-global
+ * one (`createAgentSession({ agentDir })`), so user-scope extension modules and
+ * provider policy must resolve against the caller's profile rather than
+ * `getAgentDir()`.
+ */
+export interface DiscoverExtensionsOptions {
+	/**
+	 * Agent directory backing user-scope discovery. Default: `getAgentDir()`.
+	 * Only the native capability provider is scoped this way; installed
+	 * plugin-bundle extension paths stay home-scoped by design.
+	 */
+	agentDir?: string;
+	/** Resolver-owned classification for `agentDir`. */
+	profileAuthority?: "default" | "custom";
+	/** Session settings whose provider policy applies to this load. */
+	settings?: Settings;
+}
+
 /**
  * Discover and load extensions from standard locations.
  */
@@ -737,14 +758,21 @@ export async function discoverAndLoadExtensions(
 	cwd: string,
 	eventBus?: EventBus,
 	disabledExtensionIds: string[] = [],
+	options: DiscoverExtensionsOptions = {},
 ): Promise<LoadExtensionsResult> {
 	const allPaths: string[] = [];
 	const seen = new Set<string>();
 	const disabled = new Set(disabledExtensionIds);
+	// Environmental failures on a configured entry degrade to recorded errors instead
+	// of aborting the whole load, so one unreadable, unresolvable, or pathological
+	// entry — including a directory whose entries cannot be resolved — cannot drop
+	// every other extension the session would have loaded.
+	const discoveryErrors: Array<{ path: string; error: string }> = [];
 
 	const isDisabledName = (name: string): boolean => disabled.has(`extension-module:${name}`);
 
 	const addPath = (extPath: string): void => {
+		if (isDisabledName(getExtensionNameFromPath(extPath))) return;
 		const resolved = path.resolve(extPath);
 		if (!seen.has(resolved)) {
 			seen.add(resolved);
@@ -753,44 +781,77 @@ export async function discoverAndLoadExtensions(
 	};
 
 	const addPaths = (paths: string[]) => {
-		for (const extPath of paths) {
-			if (isDisabledName(getExtensionNameFromPath(extPath))) continue;
-			addPath(extPath);
-		}
+		for (const extPath of paths) addPath(extPath);
 	};
 
 	// 1. Discover extension modules via capability API (native .gjc/.pi only)
-	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, { cwd });
+	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, {
+		cwd,
+		...(options.agentDir === undefined ? {} : { agentDir: options.agentDir }),
+		...(options.profileAuthority === undefined ? {} : { profileAuthority: options.profileAuthority }),
+		...(options.settings === undefined ? {} : { settings: options.settings }),
+	});
 	for (const ext of discovered.items) {
 		if (ext._source.provider !== "native") continue;
-		if (isDisabledName(ext.name)) continue;
 		addPath(ext.path);
 	}
 
 	// 2. Discover extension entry points from installed plugins
-	addPaths(await getAllPluginExtensionPaths(cwd));
+	try {
+		addPaths(await getAllPluginExtensionPaths(cwd));
+	} catch (error) {
+		discoveryErrors.push({
+			path: "<plugin-registry>",
+			error: `Failed to read plugin extension paths: ${safeErrorDescription(error)}`,
+		});
+		logger.warn("Failed to read plugin extension paths", { error: safeErrorDescription(error) });
+	}
 
 	// 3. Explicitly configured paths
 	for (const configuredPath of configuredPaths) {
-		const resolved = resolvePath(configuredPath, cwd);
-
+		let resolved: string;
+		try {
+			resolved = resolvePath(configuredPath, cwd);
+		} catch (error) {
+			discoveryErrors.push({
+				path: safeErrorDescription(configuredPath),
+				error: `Failed to resolve extension path: ${safeErrorDescription(error)}`,
+			});
+			continue;
+		}
 		let stat: fs1.Stats | null = null;
 		try {
 			stat = await fs.stat(resolved);
 		} catch (err) {
-			if (!isEnoent(err)) throw err;
+			if (!isEnoent(err)) {
+				discoveryErrors.push({
+					path: resolved,
+					error: `Failed to inspect extension path: ${safeErrorDescription(err)}`,
+				});
+				continue;
+			}
 		}
 
 		if (stat?.isDirectory()) {
-			const entries = await resolveExtensionEntries(resolved);
-			if (entries) {
-				addPaths(entries);
-				continue;
-			}
+			try {
+				const entries = await resolveExtensionEntries(resolved);
+				if (entries) {
+					addPaths(entries);
+					continue;
+				}
 
-			const discovered = await discoverExtensionsInDir(resolved);
-			if (discovered.length > 0) {
-				addPaths(discovered);
+				const discovered = await discoverExtensionsInDir(resolved);
+				if (discovered.length > 0) {
+					addPaths(discovered);
+				}
+			} catch (error) {
+				// Directory entry resolution rethrows non-ENOENT/EACCES/EPERM faults
+				// (ELOOP, ENAMETOOLONG, EIO). Record the offending directory and keep the
+				// modules every other source contributes instead of aborting the pass.
+				discoveryErrors.push({
+					path: resolved,
+					error: `Failed to inspect extension entries: ${safeErrorDescription(error)}`,
+				});
 			}
 			continue;
 		}
@@ -798,5 +859,6 @@ export async function discoverAndLoadExtensions(
 		addPath(resolved);
 	}
 
-	return loadExtensions(allPaths, cwd, eventBus);
+	const result = await loadExtensions(allPaths, cwd, eventBus);
+	return discoveryErrors.length === 0 ? result : { ...result, errors: [...discoveryErrors, ...result.errors] };
 }