@xopcai/xopc 0.0.302 → 0.0.306

package/dist/src/execution-environments/local-worktree-manager.js

@@ -3,8 +3,9 @@ import { init_logger } from "../utils/logger.js";
 import { ExecutionEnvironmentConflictError } from "./types.js";
 import { ExecutionEnvironmentStore } from "./store.js";
 import { findGitWorktree, inspectGitRepository, resolveGitCommit, runGit } from "./git.js";
-import { resolveExecutionWorktreesRoot, resolveManagedWorktreePath } from "./paths.js";
-import { dirname, relative, resolve } from "node:path";
+import { resolveManagedWorktreePath } from "./paths.js";
+import { assertManagedWorktreePath, assertNoNestedRegisteredWorktrees, readDirectoryIdentity, sameDirectoryIdentity } from "./worktree-safety.js";
+import { dirname, resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { mkdir, rm, stat } from "node:fs/promises";
@@ -40,12 +41,6 @@ async function isDirectory(path) {
 		return false;
 	}
 }
-function assertManagedPath(rootPath, stateDir) {
-	const managedRoot = resolveExecutionWorktreesRoot(stateDir);
-	const candidate = resolve(rootPath);
-	const child = relative(managedRoot, candidate);
-	if (!child || child.startsWith("..") || resolve(managedRoot, child) !== candidate) throw new Error(`Refusing to manage worktree outside ${managedRoot}`);
-}
 var LocalWorktreeManager = class {
 	store;
 	stateDir;
@@ -89,7 +84,7 @@ var LocalWorktreeManager = class {
 		const baseSha = await resolveGitCommit(repository.repositoryRoot, baseRef);
 		const environmentId = input.environmentId?.trim() || randomUUID();
 		const rootPath = resolveManagedWorktreePath(input.projectId, environmentId, this.stateDir);
-		assertManagedPath(rootPath, this.stateDir);
+		assertManagedWorktreePath(rootPath, this.stateDir, repository.repositoryRoot);
 		if (existsSync(rootPath)) throw new ExecutionEnvironmentConflictError(`Worktree path already exists: ${rootPath}`);
 		const environment = this.store.create({
 			id: environmentId,
@@ -107,12 +102,15 @@ var LocalWorktreeManager = class {
 			toStatus: "provisioning",
 			reason: "managed worktree provisioning started"
 		});
+		let createdDirectory;
 		try {
 			await withRepositoryLock(repository.gitCommonDir, async () => {
 				await mkdir(dirname(rootPath), {
 					recursive: true,
 					mode: 448
 				});
+				await mkdir(rootPath, { mode: 448 });
+				createdDirectory = await readDirectoryIdentity(rootPath);
 				await runGit(repository.repositoryRoot, [
 					"worktree",
 					"add",
@@ -137,7 +135,7 @@ var LocalWorktreeManager = class {
 			}, "Managed worktree ready");
 			return ready;
 		} catch (error) {
-			await this.cleanupFailedProvision(repository.repositoryRoot, repository.gitCommonDir, rootPath);
+			await this.cleanupFailedProvision(repository.repositoryRoot, repository.gitCommonDir, rootPath, createdDirectory);
 			const failed = this.store.transition({
 				environmentId: environment.id,
 				expectedVersion: provisioning.version,
@@ -235,7 +233,8 @@ var LocalWorktreeManager = class {
 			return deleted;
 		}
 		if (environment.kind !== "managed_worktree" || !environment.repositoryRoot || !environment.gitCommonDir) throw new Error(`Execution environment ${environmentId} is not a managed worktree`);
-		assertManagedPath(environment.rootPath, this.stateDir);
+		if (environment.ownership !== "xopc_created") throw new ExecutionEnvironmentConflictError(`Managed worktree ${environmentId} is not owned by xopc`);
+		assertManagedWorktreePath(environment.rootPath, this.stateDir, environment.repositoryRoot);
 		if (this.store.listBindings(environmentId).some((binding) => binding.conversationId !== options?.releaseConversationId)) throw new ExecutionEnvironmentConflictError(`Managed worktree ${environmentId} still has active bindings`);
 		const deleting = environment.status === "deleting" ? environment : this.store.transition({
 			environmentId,
@@ -245,6 +244,8 @@ var LocalWorktreeManager = class {
 		});
 		try {
 			await withRepositoryLock(environment.gitCommonDir, async () => {
+				await readDirectoryIdentity(environment.rootPath);
+				await assertNoNestedRegisteredWorktrees(environment.repositoryRoot, environment.rootPath);
 				const registered = await findGitWorktree(environment.repositoryRoot, environment.rootPath);
 				if (!registered && existsSync(environment.rootPath)) throw new ExecutionEnvironmentConflictError("Refusing to delete a directory no longer registered as this worktree");
 				if (registered) {
@@ -301,7 +302,7 @@ var LocalWorktreeManager = class {
 			throw error;
 		}
 	}
-	async cleanupFailedProvision(repositoryRoot, gitCommonDir, rootPath) {
+	async cleanupFailedProvision(repositoryRoot, gitCommonDir, rootPath, createdDirectory) {
 		await withRepositoryLock(gitCommonDir, async () => {
 			if (await findGitWorktree(repositoryRoot, rootPath).catch(() => void 0)) {
 				await runGit(repositoryRoot, [
@@ -309,14 +310,15 @@ var LocalWorktreeManager = class {
 					"unlock",
 					rootPath
 				]).catch(() => "");
-				await runGit(repositoryRoot, [
+				if (!await runGit(repositoryRoot, [
 					"worktree",
 					"remove",
 					"--force",
 					rootPath
-				]).catch(() => "");
+				]).then(() => true, () => false) || await findGitWorktree(repositoryRoot, rootPath).catch(() => void 0)) return;
 			}
-			if (existsSync(rootPath)) await rm(rootPath, {
+			const currentDirectory = await readDirectoryIdentity(rootPath);
+			if (createdDirectory && sameDirectoryIdentity(createdDirectory, currentDirectory)) await rm(rootPath, {
 				recursive: true,
 				force: true
 			});

package/dist/src/execution-environments/store.js

@@ -17,6 +17,7 @@ function environmentFromRow(row) {
 		id: row.environment_id,
 		...row.project_id ? { projectId: row.project_id } : {},
 		kind: row.kind,
+		ownership: row.ownership,
 		status: row.status,
 		rootPath: row.root_path,
 		...row.repository_root ? { repositoryRoot: row.repository_root } : {},
@@ -63,13 +64,14 @@ var ExecutionEnvironmentStore = class {
 		const repositoryRoot = optionalText(input.repositoryRoot);
 		const gitCommonDir = optionalText(input.gitCommonDir);
 		if (input.kind === "managed_worktree" && (!repositoryRoot || !gitCommonDir)) throw new Error("managed_worktree requires repositoryRoot and gitCommonDir");
+		const ownership = input.kind === "managed_worktree" ? "xopc_created" : "registered";
 		const now = Date.now();
 		runSqliteWriteTransaction((db) => {
 			db.prepare(`INSERT INTO execution_environments (
-          environment_id, project_id, kind, status, root_path,
+          environment_id, project_id, kind, ownership, status, root_path,
           repository_root, git_common_dir, base_ref, base_sha, branch_ref,
           version, created_at, updated_at
-        ) VALUES (?, ?, ?, 'requested', ?, ?, ?, ?, ?, ?, 1, ?, ?)`).run(id, projectId ?? null, input.kind, rootPath, repositoryRoot ? resolve(repositoryRoot) : null, gitCommonDir ? resolve(gitCommonDir) : null, optionalText(input.baseRef) ?? null, optionalText(input.baseSha) ?? null, optionalText(input.branchRef) ?? null, now, now);
+        ) VALUES (?, ?, ?, ?, 'requested', ?, ?, ?, ?, ?, ?, 1, ?, ?)`).run(id, projectId ?? null, input.kind, ownership, rootPath, repositoryRoot ? resolve(repositoryRoot) : null, gitCommonDir ? resolve(gitCommonDir) : null, optionalText(input.baseRef) ?? null, optionalText(input.baseSha) ?? null, optionalText(input.branchRef) ?? null, now, now);
 			db.prepare(`INSERT INTO execution_environment_events (
           event_id, environment_id, from_status, to_status, reason, metadata_json, created_at
         ) VALUES (?, ?, NULL, 'requested', 'created', '{}', ?)`).run(randomUUID(), id, now);

package/dist/src/execution-environments/types.d.ts

@@ -1,11 +1,14 @@
 export declare const EXECUTION_ENVIRONMENT_KINDS: readonly ["local_checkout", "managed_worktree"];
 export type ExecutionEnvironmentKind = (typeof EXECUTION_ENVIRONMENT_KINDS)[number];
+export declare const EXECUTION_ENVIRONMENT_OWNERSHIPS: readonly ["registered", "xopc_created"];
+export type ExecutionEnvironmentOwnership = (typeof EXECUTION_ENVIRONMENT_OWNERSHIPS)[number];
 export declare const EXECUTION_ENVIRONMENT_STATUSES: readonly ["requested", "provisioning", "ready", "degraded", "deleting", "deleted", "error"];
 export type ExecutionEnvironmentStatus = (typeof EXECUTION_ENVIRONMENT_STATUSES)[number];
 export interface ExecutionEnvironment {
     id: string;
     projectId?: string;
     kind: ExecutionEnvironmentKind;
+    ownership: ExecutionEnvironmentOwnership;
     status: ExecutionEnvironmentStatus;
     rootPath: string;
     repositoryRoot?: string;

package/dist/src/execution-environments/types.js

@@ -1,5 +1,6 @@
 //#region src/execution-environments/types.ts
 const EXECUTION_ENVIRONMENT_KINDS = ["local_checkout", "managed_worktree"];
+const EXECUTION_ENVIRONMENT_OWNERSHIPS = ["registered", "xopc_created"];
 const EXECUTION_ENVIRONMENT_STATUSES = [
 	"requested",
 	"provisioning",
@@ -51,4 +52,4 @@ function canTransitionExecutionEnvironment(fromStatus, toStatus) {
 	return STATUS_TRANSITIONS[fromStatus].includes(toStatus);
 }
 //#endregion
-export { EXECUTION_ENVIRONMENT_KINDS, EXECUTION_ENVIRONMENT_STATUSES, ExecutionEnvironmentConflictError, ExecutionEnvironmentNotFoundError, canTransitionExecutionEnvironment };
+export { EXECUTION_ENVIRONMENT_KINDS, EXECUTION_ENVIRONMENT_OWNERSHIPS, EXECUTION_ENVIRONMENT_STATUSES, ExecutionEnvironmentConflictError, ExecutionEnvironmentNotFoundError, canTransitionExecutionEnvironment };

package/dist/src/execution-environments/worktree-safety.d.ts

@@ -0,0 +1,8 @@
+export interface DirectoryIdentity {
+    dev: number;
+    ino: number;
+}
+export declare function assertManagedWorktreePath(rootPath: string, stateDir?: string, repositoryRoot?: string): void;
+export declare function readDirectoryIdentity(path: string): Promise<DirectoryIdentity | undefined>;
+export declare function assertNoNestedRegisteredWorktrees(repositoryRoot: string, rootPath: string): Promise<void>;
+export declare function sameDirectoryIdentity(expected: DirectoryIdentity, actual: DirectoryIdentity | undefined): boolean;

package/dist/src/execution-environments/worktree-safety.js

@@ -0,0 +1,43 @@
+import { listGitWorktrees } from "./git.js";
+import { resolveExecutionWorktreesRoot } from "./paths.js";
+import { homedir } from "node:os";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { lstat } from "node:fs/promises";
+//#region src/execution-environments/worktree-safety.ts
+function isInside(parent, candidate) {
+	const child = relative(parent, candidate);
+	return Boolean(child) && !isAbsolute(child) && child !== ".." && !child.startsWith(`..${sep}`) && resolve(parent, child) === candidate;
+}
+function assertManagedWorktreePath(rootPath, stateDir, repositoryRoot) {
+	const managedRoot = resolve(resolveExecutionWorktreesRoot(stateDir));
+	const candidate = resolve(rootPath);
+	if (!isInside(managedRoot, candidate)) throw new Error(`Refusing to manage worktree outside ${managedRoot}`);
+	if (candidate === resolve(homedir()) || candidate === resolve("/")) throw new Error(`Refusing to manage protected path ${candidate}`);
+	if (repositoryRoot && candidate === resolve(repositoryRoot)) throw new Error("Refusing to manage the repository root as a worktree");
+}
+async function readDirectoryIdentity(path) {
+	try {
+		const value = await lstat(path);
+		if (value.isSymbolicLink()) throw new Error(`Refusing to manage symlinked worktree path: ${path}`);
+		if (!value.isDirectory()) throw new Error(`Worktree path is not a directory: ${path}`);
+		return {
+			dev: value.dev,
+			ino: value.ino
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+}
+async function assertNoNestedRegisteredWorktrees(repositoryRoot, rootPath) {
+	const candidate = resolve(rootPath);
+	for (const worktree of await listGitWorktrees(repositoryRoot)) {
+		const registered = resolve(worktree.path);
+		if (registered !== candidate && isInside(candidate, registered)) throw new Error(`Refusing to remove worktree containing registered worktree ${registered}`);
+	}
+}
+function sameDirectoryIdentity(expected, actual) {
+	return actual?.dev === expected.dev && actual.ino === expected.ino;
+}
+//#endregion
+export { assertManagedWorktreePath, assertNoNestedRegisteredWorktrees, readDirectoryIdentity, sameDirectoryIdentity };

package/dist/src/extensions/activation-planner.d.ts

@@ -25,7 +25,7 @@ export declare class ActivationPlanner {
     getActivatedIds(context: ActivationContext): string[];
     /**
      * Split activated ids by manifest `activation.onStartup`.
-     * Extensions without the field remain on the startup path (backward compatible).
+     * Extensions without the field load during startup.
      */
     filterActivatedIdsByLoadPhase(activatedIds: readonly string[], phase: ActivationLoadPhase): string[];
     explainPlan(context: ActivationContext): string;

package/dist/src/extensions/activation-planner.js

@@ -131,7 +131,7 @@ var ActivationPlanner = class {
 	}
 	/**
 	* Split activated ids by manifest `activation.onStartup`.
-	* Extensions without the field remain on the startup path (backward compatible).
+	* Extensions without the field load during startup.
 	*/
 	filterActivatedIdsByLoadPhase(activatedIds, phase) {
 		return activatedIds.filter((extensionId) => {

package/dist/src/extensions/api-version.d.ts

@@ -0,0 +1,4 @@
+import { type EngineCheckResult } from './engine-check.js';
+export declare const EXTENSION_API_VERSION = "1.0.0";
+export declare const EXTENSION_UI_API_VERSION = "1.0.0";
+export declare function checkExtensionApiCompatibility(requiredRange: string | undefined, currentVersion: string, engineName: 'extensionApi' | 'extensionUiApi'): EngineCheckResult;

package/dist/src/extensions/api-version.js

@@ -0,0 +1,15 @@
+import { checkEngineCompatibility } from "./engine-check.js";
+//#region src/extensions/api-version.ts
+const EXTENSION_API_VERSION = "1.0.0";
+const EXTENSION_UI_API_VERSION = "1.0.0";
+function checkExtensionApiCompatibility(requiredRange, currentVersion, engineName) {
+	if (!requiredRange) return { compatible: true };
+	const result = checkEngineCompatibility(currentVersion, requiredRange);
+	if (!result.compatible || result.parseWarning) return {
+		...result,
+		reason: result.parseWarning ? `Could not parse engines.${engineName} range: "${requiredRange}"` : `${engineName} version ${currentVersion} does not satisfy engines.${engineName}: "${requiredRange}"`
+	};
+	return result;
+}
+//#endregion
+export { EXTENSION_API_VERSION, EXTENSION_UI_API_VERSION, checkExtensionApiCompatibility };

package/dist/src/extensions/api.d.ts

@@ -5,7 +5,7 @@
  */
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { Command } from 'commander';
-import type { ExtensionApi, ExtensionLogger, ExtensionRuntime, GatewayMethodHandler, HttpRequestHandler, ExtensionCommand, ExtensionCommandHandler, ExtensionReloadHandler, ExtensionService, FlagConfig, FlagValue, ShortcutConfig, HookHandlerMap, ExtensionHookEvent, TuiExtensionRegistrar, ExtensionSendUserMessageOptions, ExtensionUserMessageContent, ExtensionCustomMessage, ExtensionSendMessageOptions } from './types/index.js';
+import type { ExtensionApi, ExtensionLogger, ExtensionRuntime, GatewayMethodHandler, HttpRequestHandler, ExtensionCommand, ExtensionCommandHandler, ExtensionReloadHandler, ExtensionService, HookHandlerMap, ExtensionHookEvent, TuiExtensionRegistrar, ExtensionSendUserMessageOptions, ExtensionUserMessageContent, ExtensionCustomMessage, ExtensionSendMessageOptions } from './types/index.js';
 import type { CommandContribution, ContractDeclaration } from './types/manifest.js';
 import type { ChannelPlugin } from '../channels/plugin-types.js';
 import type { Config } from '../config/config-surface.js';
@@ -38,6 +38,7 @@ export declare class ExtensionApiImpl implements ExtensionApi {
     private _registeredSpeechProviderIds;
     private _registeredMediaUnderstandingProviderIds;
     private _registeredMarketplaceAdapterIds;
+    private _providerCleanup;
     private readonly _manifestCommands;
     constructor(id: string, name: string, version: string | undefined, source: string, config: Config, extensionConfig: Record<string, unknown>, _logger: ExtensionLogger, _resolvePath: (input: string) => string, _coreRegistry?: ExtensionRegistryImpl, _contracts?: ContractDeclaration, runtime?: ExtensionRuntime);
     get logger(): ExtensionLogger;
@@ -58,7 +59,7 @@ export declare class ExtensionApiImpl implements ExtensionApi {
      *   return { systemPrompt: event.systemPrompt };
      * });
      */
-    onHook<K extends ExtensionHookEvent>(hookName: K, handler: HookHandlerMap[K], _opts?: {
+    onHook<K extends ExtensionHookEvent>(hookName: K, handler: HookHandlerMap[K], opts?: {
         priority?: number;
     }): void;
     /**
@@ -94,10 +95,6 @@ export declare class ExtensionApiImpl implements ExtensionApi {
      * Register a full ProviderPlugin
      */
     registerProvider(plugin: import('./types/providers.js').ProviderPlugin): void;
-    /**
-     * Register a full ProviderPlugin (alias for registerProvider)
-     */
-    registerProviderPlugin(plugin: import('./types/providers.js').ProviderPlugin): void;
     registerSpeechProvider(plugin: SpeechProviderPlugin): void;
     /** Speech provider ids registered through this extension API instance. */
     getRegisteredSpeechProviderIds(): readonly string[];
@@ -111,9 +108,6 @@ export declare class ExtensionApiImpl implements ExtensionApi {
         adapter: import('../agent/skills/marketplace/adapter.types.js').SkillsMarketplaceAdapter;
         displayName?: string;
     }): void;
-    registerFlag(_name: string, _config: FlagConfig): void;
-    getFlag(_name: string): FlagValue;
-    registerShortcut(_key: string, _config: ShortcutConfig): void;
     registerTui(register: TuiExtensionRegistrar): void;
     setLabel(entryId: string, label: string | undefined): void;
     sendUserMessage(content: ExtensionUserMessageContent, options?: ExtensionSendUserMessageOptions): void;

package/dist/src/extensions/api.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { getProviderRegistry, init_plugin_registry } from "../providers/plugin-registry.js";
 import { registerMarketplaceAdapter, unregisterMarketplaceAdapter } from "../agent/skills/marketplace/registry.js";
 import { registerSpeechProvider } from "../voice/tts/speech-registry.js";
 import { HOOK_EXECUTION_MODES } from "./types/hooks.js";
@@ -12,6 +13,7 @@ import { isAbsolute, resolve } from "path";
 import { EventEmitter } from "events";
 //#region src/extensions/api.ts
 init_logger();
+init_plugin_registry();
 var ExtensionApiImpl = class {
 	_tools = /* @__PURE__ */ new Map();
 	_hooks = /* @__PURE__ */ new Map();
@@ -25,6 +27,7 @@ var ExtensionApiImpl = class {
 	_registeredSpeechProviderIds = [];
 	_registeredMediaUnderstandingProviderIds = [];
 	_registeredMarketplaceAdapterIds = [];
+	_providerCleanup = [];
 	_manifestCommands = /* @__PURE__ */ new Map();
 	constructor(id, name, version, source, config, extensionConfig, _logger, _resolvePath, _coreRegistry, _contracts = {}, runtime) {
 		this.id = id;
@@ -68,15 +71,17 @@ var ExtensionApiImpl = class {
 	registerHook(event, handler, opts) {
 		this._assertContract("hooks", event);
 		if (!this._hooks.has(event)) this._hooks.set(event, /* @__PURE__ */ new Set());
-		this._hooks.get(event).add(handler);
-		if (opts?.once) {
-			const wrapper = async (...args) => {
-				await handler(...args);
-				this._hooks.get(event)?.delete(wrapper);
-			};
-			this._hooks.get(event).add(wrapper);
-		}
-		this._registry.addHook(event, handler, this.id, opts?.priority ?? 0);
+		const hookEvent = event;
+		const registeredHandler = opts?.once ? async (...args) => {
+			try {
+				return await handler(...args);
+			} finally {
+				this._hooks.get(event)?.delete(registeredHandler);
+				this._registry.removeHook(hookEvent, registeredHandler);
+			}
+		} : handler;
+		this._hooks.get(event).add(registeredHandler);
+		this._registry.addHook(hookEvent, registeredHandler, this.id, opts?.priority ?? 0);
 		this._logger.info(`Registered hook: ${event}`);
 	}
 	/**
@@ -89,11 +94,12 @@ var ExtensionApiImpl = class {
 	*   return { systemPrompt: event.systemPrompt };
 	* });
 	*/
-	onHook(hookName, handler, _opts) {
+	onHook(hookName, handler, opts) {
 		this._assertContract("hooks", hookName);
 		const mode = HOOK_EXECUTION_MODES[hookName];
 		if (!this._typedHooks.has(hookName)) this._typedHooks.set(hookName, /* @__PURE__ */ new Set());
 		this._typedHooks.get(hookName).add(handler);
+		this._registry.addHook(hookName, handler, this.id, opts?.priority ?? 0);
 		this._logger.debug(`Registered typed hook: ${hookName} (mode: ${mode})`);
 	}
 	/**
@@ -107,14 +113,14 @@ var ExtensionApiImpl = class {
 	registerChannel(registration) {
 		const plugin = registration.plugin;
 		this._assertContract("channels", plugin.id);
-		this._registry.addChannelPlugin(plugin);
+		this._registry.addChannelPlugin(plugin, this.id);
 		for (const migration of plugin.migrations ?? []) this.registerMigration(migration);
 		this._eventBus.emit("channel:register", plugin);
 		this._logger.info(`Registered channel plugin: ${plugin.id}`);
 	}
 	registerHttpRoute(path, handler) {
 		this._assertContract("httpRoutes", path);
-		this._registry.addHttpRoute(path, handler);
+		this._registry.addHttpRoute(path, handler, this.id);
 		this._eventBus.emit("http:route", {
 			path,
 			handler
@@ -154,7 +160,7 @@ var ExtensionApiImpl = class {
 		};
 		commandRegistry.register(definition);
 		this._registeredCommandIds.push(commandId);
-		this._registry.addCommand(command);
+		this._registry.addCommand(command, this.id);
 		this._eventBus.emit("command:register", command);
 		this._logger.info(`Registered chat command: /${command.name}`);
 	}
@@ -200,13 +206,13 @@ var ExtensionApiImpl = class {
 	}
 	registerService(service) {
 		this._assertContract("services", service.id);
-		this._registry.addService(service);
+		this._registry.addService(service, this.id);
 		this._eventBus.emit("service:register", service);
 		this._logger.info(`Registered service: ${service.id}`);
 	}
 	registerGatewayMethod(method, handler) {
 		this._assertContract("gatewayMethods", method);
-		this._registry.addGatewayMethod(method, handler);
+		this._registry.addGatewayMethod(method, handler, this.id);
 		this._eventBus.emit("gateway:method", {
 			method,
 			handler
@@ -244,22 +250,12 @@ var ExtensionApiImpl = class {
 	*/
 	registerProvider(plugin) {
 		this._assertContract("providers", plugin.id);
-		import("../providers/plugin-registry.js").then(({ getProviderRegistry }) => {
-			getProviderRegistry().register(plugin);
-			this._logger.info(`Extension registered provider: ${plugin.id}`);
-		}).catch((err) => {
-			this._logger.error(`Failed to register provider: ${err instanceof Error ? err.message : String(err)}`);
-		});
-	}
-	/**
-	* Register a full ProviderPlugin (alias for registerProvider)
-	*/
-	registerProviderPlugin(plugin) {
-		this.registerProvider(plugin);
+		this._providerCleanup.push(getProviderRegistry().register(plugin));
+		this._logger.info(`Extension registered provider: ${plugin.id}`);
 	}
 	registerSpeechProvider(plugin) {
 		this._assertContract("speechProviders", plugin.id);
-		registerSpeechProvider(plugin);
+		this._providerCleanup.push(registerSpeechProvider(plugin));
 		if (!this._registeredSpeechProviderIds.includes(plugin.id)) this._registeredSpeechProviderIds.push(plugin.id);
 		this._logger.info(`Registered speech provider: ${plugin.id}`);
 	}
@@ -269,7 +265,7 @@ var ExtensionApiImpl = class {
 	}
 	registerMediaUnderstandingProvider(plugin) {
 		this._assertContract("mediaUnderstandingProviders", plugin.id);
-		registerMediaUnderstandingProvider(plugin);
+		this._providerCleanup.push(registerMediaUnderstandingProvider(plugin));
 		if (!this._registeredMediaUnderstandingProviderIds.includes(plugin.id)) this._registeredMediaUnderstandingProviderIds.push(plugin.id);
 		this._logger.info(`Registered media understanding provider: ${plugin.id}`);
 	}
@@ -287,9 +283,6 @@ var ExtensionApiImpl = class {
 		if (!this._registeredMarketplaceAdapterIds.includes(adapterId)) this._registeredMarketplaceAdapterIds.push(adapterId);
 		this._logger.info(`Extension registered marketplace adapter: ${adapterId}`);
 	}
-	registerFlag(_name, _config) {}
-	getFlag(_name) {}
-	registerShortcut(_key, _config) {}
 	registerTui(register) {
 		this._assertContract("tui", this.id);
 		this._registry.addTuiRegistration(this.id, register);
@@ -323,6 +316,7 @@ var ExtensionApiImpl = class {
 		this._registry.removeReloadRegistration(this.id);
 		for (const adapterId of this._registeredMarketplaceAdapterIds) unregisterMarketplaceAdapter(adapterId);
 		this._registeredMarketplaceAdapterIds = [];
+		for (const cleanup of this._providerCleanup.splice(0).reverse()) cleanup();
 		this._typedEventBus.cleanupAll();
 		this._eventBus.removeAllListeners();
 		this._hooks.clear();

package/dist/src/extensions/config-validation.d.ts

@@ -0,0 +1,8 @@
+export type ExtensionConfigValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+    errors?: unknown;
+};
+export declare function validateExtensionConfig(schema: Record<string, unknown> | undefined, config: Record<string, unknown>): ExtensionConfigValidationResult;

package/dist/src/extensions/config-validation.js

@@ -0,0 +1,25 @@
+import Ajv from "ajv";
+//#region src/extensions/config-validation.ts
+const validator = new Ajv({
+	allErrors: true,
+	strict: false
+});
+function validateExtensionConfig(schema, config) {
+	if (!schema) return { valid: true };
+	try {
+		const validate = validator.compile(schema);
+		if (validate(config)) return { valid: true };
+		return {
+			valid: false,
+			reason: validator.errorsText(validate.errors, { separator: "; " }),
+			errors: validate.errors
+		};
+	} catch (error) {
+		return {
+			valid: false,
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+//#endregion
+export { validateExtensionConfig };

package/dist/src/extensions/extension-registry-impl.d.ts

@@ -3,8 +3,7 @@
  * without going through `loader.ts` (which imports back from `api.ts`,
  * forming a circular cycle).
  *
- * `loader.ts` still re-exports the class for backward-compat; this file is a
- * leaf and only depends on the type definitions in `./types/index.js`.
+ * This file is a leaf and only depends on the type definitions in `./types/index.js`.
  */
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { ChannelPlugin } from '../channels/plugin-types.js';
@@ -18,6 +17,13 @@ export declare class ExtensionRegistryImpl implements ExtensionRegistry {
     gatewayMethods: Map<string, GatewayMethodHandler>;
     tools: Map<string, AgentTool<any, any>>;
     private toolExtensionIds;
+    private hookOwners;
+    private hookPriorities;
+    private channelOwners;
+    private httpRouteOwners;
+    private commandOwners;
+    private serviceOwners;
+    private gatewayMethodOwners;
     channelPlugins: ChannelPlugin[];
     private cliRegistrations;
     private reloadRegistrations;
@@ -26,17 +32,22 @@ export declare class ExtensionRegistryImpl implements ExtensionRegistry {
     addExtension(record: ExtensionRecord): void;
     getExtension(id: string): ExtensionRecord | undefined;
     getEnabledExtensions(): ExtensionRecord[];
-    addHook(event: ExtensionHookEvent, handler: ExtensionHookHandler, _extensionId: string, _priority?: number): void;
+    addHook(event: ExtensionHookEvent, handler: ExtensionHookHandler, extensionId: string, priority?: number): void;
+    removeHook(event: ExtensionHookEvent, handler: ExtensionHookHandler): void;
     getHooks(event: ExtensionHookEvent): ExtensionHookHandler[];
-    addChannelPlugin(plugin: ChannelPlugin): void;
-    addHttpRoute(path: string, handler: HttpRequestHandler): void;
-    getHttpRoute(path: string): HttpRequestHandler | undefined;
-    addCommand(command: ExtensionCommand): void;
+    addChannelPlugin(plugin: ChannelPlugin, extensionId?: string): void;
+    addHttpRoute(path: string, handler: HttpRequestHandler, extensionId?: string): void;
+    getHttpRoute(extensionId: string, path: string): HttpRequestHandler | undefined;
+    addCommand(command: ExtensionCommand, extensionId?: string): void;
     getCommand(name: string): ExtensionCommand | undefined;
-    addService(service: ExtensionService): void;
+    addService(service: ExtensionService, extensionId?: string): void;
     getService(id: string): ExtensionService | undefined;
-    addGatewayMethod(method: string, handler: GatewayMethodHandler): void;
+    addGatewayMethod(method: string, handler: GatewayMethodHandler, extensionId?: string): void;
     getGatewayMethod(method: string): GatewayMethodHandler | undefined;
+    getServicesForExtension(extensionId: string): ExtensionService[];
+    removeExtensionContributions(extensionId: string): void;
+    private removeOwnedEntries;
+    private httpRouteKey;
     addTool(tool: any, extensionId: string): void;
     removeTool(name: string): void;
     getTools(): Map<string, any>;