agent-detective 1.0.0

package/dist/chunk-OIYJYLCB.js

@@ -0,0 +1,685 @@
+#!/usr/bin/env node
+
+// src/core/queue.ts
+function createLimitedConcurrencyTaskQueue(inner, maxConcurrent, logger) {
+  if (maxConcurrent < 1) {
+    throw new Error("maxConcurrent must be at least 1");
+  }
+  let active = 0;
+  const waiters = [];
+  async function acquire() {
+    if (active < maxConcurrent) {
+      active += 1;
+      return;
+    }
+    await new Promise((resolve2) => {
+      waiters.push(() => {
+        active += 1;
+        resolve2();
+      });
+    });
+  }
+  function release() {
+    active -= 1;
+    const next = waiters.shift();
+    if (next) next();
+  }
+  return {
+    enqueue(queueKey, fn) {
+      return inner.enqueue(queueKey, async () => {
+        await acquire();
+        const waitersDepth = waiters.length;
+        if (waitersDepth > 0 && waitersDepth % 10 === 0) {
+          logger.info(`task_concurrency_queue depth=${waitersDepth} max=${maxConcurrent}`);
+        }
+        try {
+          await fn();
+        } finally {
+          release();
+        }
+      });
+    },
+    shutdown: inner.shutdown
+  };
+}
+function createEnqueue(queues, logger) {
+  return function enqueue(queueKey, fn) {
+    const enqueuedAt = Date.now();
+    const prevTail = queues.get(queueKey) || Promise.resolve();
+    const work = prevTail.then(() => {
+      const queueWaitMs = Date.now() - enqueuedAt;
+      logger.info(`queue_start key=${queueKey} queue_wait_ms=${queueWaitMs}`);
+      return fn();
+    });
+    const nextTail = work.catch((err) => {
+      const e = err instanceof Error ? err : new Error(String(err));
+      logger.error(`queue_error key=${queueKey}: ${e.message}`);
+    });
+    queues.set(queueKey, nextTail);
+    work.finally(() => {
+      if (queues.get(queueKey) === nextTail) {
+        queues.delete(queueKey);
+      }
+    });
+    return work;
+  };
+}
+function createMemoryTaskQueue(logger) {
+  const queues = /* @__PURE__ */ new Map();
+  return { enqueue: createEnqueue(queues, logger) };
+}
+
+// src/core/schema-validator.ts
+var SCHEMA_VERSION = "1.0";
+function validatePluginSchema(pluginExport) {
+  if (!pluginExport || typeof pluginExport !== "object") {
+    throw new Error("Plugin must export an object");
+  }
+  const plugin = pluginExport;
+  if (typeof plugin.name !== "string" || !plugin.name) {
+    throw new Error("Plugin must have a name string");
+  }
+  if (typeof plugin.version !== "string" || !plugin.version) {
+    throw new Error("Plugin must have a version string");
+  }
+  if (typeof plugin.register !== "function") {
+    throw new Error("Plugin must export a register function");
+  }
+  if (!plugin.schemaVersion) {
+    throw new Error(`Plugin must declare schemaVersion: '${SCHEMA_VERSION}'`);
+  }
+  if (plugin.schemaVersion !== SCHEMA_VERSION) {
+    throw new Error(`Plugin schema version mismatch: expected ${SCHEMA_VERSION}, got ${plugin.schemaVersion}`);
+  }
+  return true;
+}
+function validatePluginConfig(pluginExport, config) {
+  if (!pluginExport.schema) {
+    return config || {};
+  }
+  const schema = pluginExport.schema;
+  const errors = [];
+  if (schema.required) {
+    for (const field of schema.required) {
+      if (config?.[field] === void 0) {
+        errors.push(`Required field missing: ${field}`);
+      }
+    }
+  }
+  if (schema.properties && config) {
+    for (const [key, value] of Object.entries(config)) {
+      if (!schema.properties[key]) {
+        errors.push(`Unrecognized key: "${key}"`);
+        continue;
+      }
+      const propSchema = schema.properties[key];
+      if (propSchema.type === "string" && typeof value !== "string") {
+        errors.push(`${key} must be a string`);
+      }
+      if (propSchema.type === "boolean" && typeof value !== "boolean") {
+        errors.push(`${key} must be a boolean`);
+      }
+      if (propSchema.type === "number" && typeof value !== "number") {
+        errors.push(`${key} must be a number`);
+      }
+      if (propSchema.type === "array" && !Array.isArray(value)) {
+        errors.push(`${key} must be an array`);
+      }
+      if (propSchema.type === "object" && (typeof value !== "object" || value === null || Array.isArray(value))) {
+        errors.push(`${key} must be an object`);
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Invalid plugin config: ${errors.join(", ")}`);
+  }
+  return config || {};
+}
+
+// src/core/plugin-system.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+import { CODE_ANALYSIS_SERVICE, REPO_CONTEXT_SERVICE, StandardCapabilities } from "@agent-detective/sdk";
+
+// src/core/built-in-plugins.ts
+import jiraAdapter from "@agent-detective/jira-adapter";
+import linearAdapter from "@agent-detective/linear-adapter";
+import localRepos from "@agent-detective/local-repos-plugin";
+import prPipeline from "@agent-detective/pr-pipeline";
+function normalizeModule(mod) {
+  const m = mod;
+  return (m && typeof m === "object" && "default" in m ? m.default : m) ?? mod;
+}
+var builtIns = {
+  "@agent-detective/local-repos-plugin": normalizeModule(localRepos),
+  "@agent-detective/jira-adapter": normalizeModule(jiraAdapter),
+  "@agent-detective/linear-adapter": normalizeModule(linearAdapter),
+  "@agent-detective/pr-pipeline": normalizeModule(prPipeline)
+};
+function getBuiltInPlugin(spec) {
+  return builtIns[spec] ?? null;
+}
+
+// src/core/plugin-system.ts
+async function importPluginModuleFromSpecifier(spec, resolveRootDir) {
+  const builtIn = getBuiltInPlugin(spec);
+  if (builtIn) {
+    return { default: builtIn };
+  }
+  if (spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/")) {
+    return import(pathToFileURL(resolve(resolveRootDir, spec)).href);
+  }
+  try {
+    return await import(spec);
+  } catch {
+    const short = spec.replace("@agent-detective/", "");
+    const base = resolve(resolveRootDir, "packages", short);
+    const distJs = resolve(base, "dist/index.js");
+    const srcJs = resolve(base, "src/index.js");
+    let filePath = null;
+    if (existsSync(distJs)) filePath = distJs;
+    else if (existsSync(srcJs)) filePath = srcJs;
+    if (!filePath) {
+      throw new Error(
+        `Failed to resolve ${spec} from monorepo fallback. Expected ${distJs} (run workspace build) or ${srcJs} (JS source).`
+      );
+    }
+    return import(pathToFileURL(filePath).href);
+  }
+}
+function sanitizePluginName(name) {
+  return name.replace(/^@/, "").replace(/\//g, "-");
+}
+function createPluginSystem(context) {
+  const {
+    agentRunner,
+    taskQueue: initialTaskQueue,
+    logger = console,
+    events,
+    metrics,
+    health,
+    pathResolutionRoot = process.cwd(),
+    failOnContractErrors = false,
+    failOnDependencyErrors = true,
+    failOnPluginLoadErrors = true
+  } = context;
+  const defaultQueue = initialTaskQueue ?? createMemoryTaskQueue(logger);
+  let activeQueue = defaultQueue;
+  const enqueueDelegate = (queueKey, fn) => activeQueue.enqueue(queueKey, fn);
+  function registerTaskQueue(queue) {
+    const previous = activeQueue;
+    activeQueue = queue;
+    try {
+      const shutdownResult = previous.shutdown?.();
+      if (shutdownResult !== void 0 && typeof shutdownResult.then === "function") {
+        shutdownResult.catch(
+          (err) => logger.warn(`Previous task queue shutdown failed: ${err.message}`)
+        );
+      }
+    } catch (err) {
+      logger.warn(`Previous task queue shutdown failed: ${err.message}`);
+    }
+  }
+  const loadedPlugins = /* @__PURE__ */ new Map();
+  const activePlugins = /* @__PURE__ */ new Set();
+  const servicesRegistry = /* @__PURE__ */ new Map();
+  const capabilitiesRegistry = /* @__PURE__ */ new Map();
+  const shutdownHooks = [];
+  let providerPriorityByPluginName = null;
+  const pluginLoadFailures = [];
+  let healthCheckRegistered = false;
+  let lastConfiguredPluginsCount = 0;
+  const MULTI_PROVIDER_SERVICE_KEYS = /* @__PURE__ */ new Set([
+    // Capability-backed services
+    REPO_CONTEXT_SERVICE,
+    CODE_ANALYSIS_SERVICE
+  ]);
+  const CAPABILITY_BACKED_CONTRACTS = [
+    { capability: StandardCapabilities.REPO_CONTEXT, serviceKey: REPO_CONTEXT_SERVICE },
+    { capability: StandardCapabilities.CODE_ANALYSIS, serviceKey: CODE_ANALYSIS_SERVICE }
+  ];
+  function isFirstPartyPlugin(pluginName) {
+    return pluginName.startsWith("@agent-detective/");
+  }
+  function registerCapabilityForPlugin(providerPluginName, capability) {
+    const existing = capabilitiesRegistry.get(capability);
+    if (!existing) {
+      capabilitiesRegistry.set(capability, /* @__PURE__ */ new Set([providerPluginName]));
+      return;
+    }
+    existing.add(providerPluginName);
+  }
+  function hasCapability(capability) {
+    const providers = capabilitiesRegistry.get(capability);
+    if (!providers || providers.size === 0) return false;
+    for (const provider of providers) {
+      if (isPluginActiveOrLoaded(provider)) return true;
+    }
+    return false;
+  }
+  function registerServiceForPlugin(providerPluginName, name, service) {
+    const existing = servicesRegistry.get(name);
+    if (!existing) {
+      servicesRegistry.set(name, /* @__PURE__ */ new Map([[providerPluginName, service]]));
+      return;
+    }
+    const hadProvider = existing.has(providerPluginName);
+    const hadAny = existing.size > 0;
+    if (hadProvider) {
+      logger.warn(`Service ${name} already registered, overwriting`);
+    } else if (hadAny && !MULTI_PROVIDER_SERVICE_KEYS.has(name)) {
+      logger.warn(`Service ${name} already registered, overwriting`);
+    }
+    existing.set(providerPluginName, service);
+  }
+  function isPluginActiveOrLoaded(name) {
+    return activePlugins.has(name) || loadedPlugins.has(name);
+  }
+  function getActiveProvidersForService(name) {
+    const providers = servicesRegistry.get(name);
+    if (!providers) return /* @__PURE__ */ new Map();
+    const active = /* @__PURE__ */ new Map();
+    for (const [providerName, svc] of providers) {
+      if (isPluginActiveOrLoaded(providerName)) {
+        active.set(providerName, svc);
+      }
+    }
+    return active;
+  }
+  function getServiceFromPlugin(name, providerPluginName) {
+    if (!isPluginActiveOrLoaded(providerPluginName)) {
+      throw new Error(
+        `Service ${name} not found for provider ${providerPluginName}. Ensure the providing plugin is loaded.`
+      );
+    }
+    const providers = getActiveProvidersForService(name);
+    const service = providers.get(providerPluginName);
+    if (!service) {
+      const knownProviders = providers ? Array.from(providers.keys()) : [];
+      const suffix = knownProviders.length ? ` Known providers: ${knownProviders.join(", ")}` : "";
+      throw new Error(
+        `Service ${name} not found for provider ${providerPluginName}. Ensure the providing plugin is loaded.${suffix}`
+      );
+    }
+    return service;
+  }
+  function selectDefaultProviderService(_name, providers) {
+    if (providers.size === 1) {
+      return providers.values().next().value;
+    }
+    const priority = providerPriorityByPluginName;
+    if (!priority) {
+      for (const [providerName, service] of providers) {
+        if (isFirstPartyPlugin(providerName)) return service;
+      }
+      return providers.values().next().value;
+    }
+    const candidates = [];
+    for (const [providerName, service] of providers) {
+      const rank = priority.get(providerName) ?? Number.MAX_SAFE_INTEGER;
+      candidates.push({ providerName, service, isFirstParty: isFirstPartyPlugin(providerName), rank });
+    }
+    candidates.sort((a, b) => {
+      if (a.isFirstParty !== b.isFirstParty) return a.isFirstParty ? -1 : 1;
+      if (a.rank !== b.rank) return a.rank - b.rank;
+      return 0;
+    });
+    return candidates[0].service;
+  }
+  function getService(name) {
+    const providers = getActiveProvidersForService(name);
+    if (!providers || providers.size === 0) {
+      throw new Error(`Service ${name} not found. Ensure the providing plugin is loaded.`);
+    }
+    return selectDefaultProviderService(name, providers);
+  }
+  function buildPluginContext(plugin, mergedConfig) {
+    return {
+      agentRunner,
+      enqueue: enqueueDelegate,
+      config: mergedConfig,
+      logger: "child" in logger && typeof logger.child === "function" ? logger.child({ plugin: plugin.name }) : logger,
+      events,
+      registerService: (name, service) => registerServiceForPlugin(plugin.name, name, service),
+      getService,
+      getServiceFromPlugin,
+      registerAgent: (agent) => agentRunner.registerAgent(agent),
+      registerCapability: (capability) => registerCapabilityForPlugin(plugin.name, capability),
+      hasCapability,
+      registerTaskQueue,
+      onShutdown: (fn) => shutdownHooks.push(fn)
+    };
+  }
+  function preparePlugin(plugin, pluginConfig) {
+    validatePluginSchema(plugin);
+    const mergedConfig = { ...pluginConfig };
+    if (plugin.schema?.properties) {
+      for (const [key, prop] of Object.entries(plugin.schema.properties)) {
+        if (mergedConfig[key] === void 0 && prop.default !== void 0) {
+          mergedConfig[key] = prop.default;
+        }
+      }
+    }
+    validatePluginConfig(plugin, mergedConfig);
+    return { mergedConfig, ctx: buildPluginContext(plugin, mergedConfig) };
+  }
+  async function loadPlugin(plugin, app, pluginConfig) {
+    if (loadedPlugins.has(plugin.name)) {
+      logger.warn(`Plugin ${plugin.name} already loaded, skipping`);
+      return loadedPlugins.get(plugin.name) ?? null;
+    }
+    let prepared;
+    try {
+      prepared = preparePlugin(plugin, pluginConfig);
+    } catch (err) {
+      pluginLoadFailures.push({ plugin: plugin.name, stage: "validate", message: err.message });
+      logger.warn(`Failed to load plugin ${plugin.name}: ${err.message}. Continuing...`);
+      return null;
+    }
+    const start = Date.now();
+    activePlugins.add(plugin.name);
+    try {
+      await plugin.register(app, prepared.ctx);
+    } catch (err) {
+      pluginLoadFailures.push({ plugin: plugin.name, stage: "register", message: err.message });
+      logger.warn(`Failed to load plugin ${plugin.name}: ${err.message}. Continuing...`);
+      return null;
+    } finally {
+      activePlugins.delete(plugin.name);
+      metrics?.pluginLoadDuration.observe({ plugin: plugin.name }, Date.now() - start);
+    }
+    const loaded = {
+      name: plugin.name,
+      version: plugin.version,
+      config: prepared.mergedConfig,
+      dependsOn: plugin.dependsOn || []
+    };
+    loadedPlugins.set(plugin.name, loaded);
+    metrics?.pluginsLoaded.set({ plugin: plugin.name }, 1);
+    const contractErrors = [];
+    if (plugin.requiresCapabilities) {
+      for (const req of plugin.requiresCapabilities) {
+        if (!hasCapability(req)) {
+          const available = Array.from(capabilitiesRegistry.keys()).sort();
+          contractErrors.push(
+            `Plugin ${plugin.name} requires capability '${req}' which is not provided by any loaded plugin.`
+          );
+          logger.error(
+            `Plugin ${plugin.name} requires capability '${req}' which is not provided by any loaded plugin. Available capabilities: ${available.length ? available.join(", ") : "(none)"}`
+          );
+        }
+      }
+    }
+    for (const { capability, serviceKey } of CAPABILITY_BACKED_CONTRACTS) {
+      const providersForCapability = capabilitiesRegistry.get(capability);
+      if (providersForCapability?.has(plugin.name)) {
+        const svcProviders = servicesRegistry.get(serviceKey);
+        if (!svcProviders || !svcProviders.has(plugin.name)) {
+          contractErrors.push(
+            `Plugin ${plugin.name} declares capability '${capability}' but did not register required service '${serviceKey}'.`
+          );
+          logger.error(
+            `Plugin ${plugin.name} declares capability '${capability}' but did not register required service '${serviceKey}'.`
+          );
+        }
+      }
+      if (plugin.requiresCapabilities?.includes(capability)) {
+        const activeProviders = getActiveProvidersForService(serviceKey);
+        if (activeProviders.size === 0) {
+          contractErrors.push(
+            `Plugin ${plugin.name} requires capability '${capability}' but no provider registered service '${serviceKey}'.`
+          );
+          logger.error(
+            `Plugin ${plugin.name} requires capability '${capability}' but no provider registered service '${serviceKey}'.`
+          );
+        }
+      }
+    }
+    if (failOnContractErrors && contractErrors.length > 0) {
+      throw new Error(
+        `Plugin contract errors detected (failOnContractErrors=true):
+- ${contractErrors.join("\n- ")}`
+      );
+    }
+    logger.info(`Loaded plugin ${plugin.name}@${plugin.version}`);
+    return loaded;
+  }
+  async function loadAll(app, config) {
+    const plugins = config.plugins || [];
+    const pluginData = /* @__PURE__ */ new Map();
+    const configOrder = [];
+    const loadOrder = [];
+    const errors = [];
+    for (const p of plugins) {
+      const packageName = typeof p === "string" ? p : p.package;
+      if (!packageName) continue;
+      let plugin;
+      try {
+        const pluginModule = await importPluginModuleFromSpecifier(packageName, pathResolutionRoot);
+        plugin = pluginModule.default ?? pluginModule;
+      } catch (err) {
+        pluginLoadFailures.push({
+          plugin: packageName,
+          stage: "import",
+          message: err.message
+        });
+        logger.warn(`Failed to load plugin metadata for ${packageName}: ${err.message}`);
+        continue;
+      }
+      if (loadedPlugins.has(plugin.name)) continue;
+      pluginData.set(plugin.name, {
+        plugin,
+        packageName,
+        options: typeof p === "object" ? p.options || {} : {}
+      });
+      configOrder.push(plugin.name);
+    }
+    providerPriorityByPluginName = new Map(configOrder.map((name, idx) => [name, idx]));
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    function visit(name, path) {
+      if (visited.has(name)) return true;
+      if (visiting.has(name)) {
+        errors.push(`Circular dependency detected: ${path.join(" -> ")} -> ${name}`);
+        return false;
+      }
+      const data = pluginData.get(name);
+      if (!data) {
+        if (loadedPlugins.has(name)) {
+          visited.add(name);
+          return true;
+        }
+        errors.push(`Plugin ${name} not found in config but required by ${path.join(" -> ")}`);
+        return false;
+      }
+      visiting.add(name);
+      const deps = data.plugin.dependsOn || [];
+      for (const dep of deps) {
+        if (!visit(dep, [...path, name])) {
+          visiting.delete(name);
+          return false;
+        }
+      }
+      visiting.delete(name);
+      visited.add(name);
+      loadOrder.push(name);
+      return true;
+    }
+    for (const name of pluginData.keys()) {
+      visit(name, [name]);
+    }
+    for (const error of errors) {
+      logger.error(`Plugin dependency error: ${error}`);
+    }
+    if (failOnDependencyErrors && errors.length > 0) {
+      throw new Error(
+        `Plugin dependency errors detected (failOnDependencyErrors=true):
+- ${errors.join("\n- ")}`
+      );
+    }
+    logger.info(`Plugin load order: ${loadOrder.join(" -> ")}`);
+    for (const name of loadOrder) {
+      const data = pluginData.get(name);
+      const { plugin, options } = data;
+      if (loadedPlugins.has(plugin.name)) {
+        logger.warn(`Plugin ${plugin.name} already loaded, skipping`);
+        continue;
+      }
+      let prepared;
+      try {
+        prepared = preparePlugin(plugin, options);
+      } catch (err) {
+        pluginLoadFailures.push({ plugin: plugin.name, stage: "validate", message: err.message });
+        logger.warn(`Failed to load plugin ${plugin.name}: ${err.message}. Continuing...`);
+        continue;
+      }
+      const prefix = `/plugins/${sanitizePluginName(plugin.name)}`;
+      app.register(
+        async (childScope) => {
+          activePlugins.add(plugin.name);
+          const start = Date.now();
+          try {
+            await plugin.register(childScope, prepared.ctx);
+            const loaded = {
+              name: plugin.name,
+              version: plugin.version,
+              config: prepared.mergedConfig,
+              dependsOn: plugin.dependsOn || []
+            };
+            loadedPlugins.set(plugin.name, loaded);
+            metrics?.pluginsLoaded.set({ plugin: plugin.name }, 1);
+            logger.info(`Loaded plugin ${plugin.name}@${plugin.version}`);
+          } catch (err) {
+            pluginLoadFailures.push({ plugin: plugin.name, stage: "register", message: err.message });
+            logger.warn(
+              `Failed to load plugin ${plugin.name}: ${err.message}. Continuing...`
+            );
+          } finally {
+            activePlugins.delete(plugin.name);
+            metrics?.pluginLoadDuration.observe({ plugin: plugin.name }, Date.now() - start);
+          }
+        },
+        { prefix }
+      );
+    }
+    await app.ready();
+    if (failOnPluginLoadErrors && pluginLoadFailures.length > 0) {
+      const rendered = pluginLoadFailures.map((f) => `${f.plugin} (${f.stage}): ${f.message}`).join("\n- ");
+      throw new Error(
+        `Plugin load errors detected (failOnPluginLoadErrors=true):
+- ${rendered}`
+      );
+    }
+    const contractErrors = [];
+    lastConfiguredPluginsCount = Array.isArray(config.plugins) ? config.plugins.length : 0;
+    if (health && !healthCheckRegistered) {
+      health.registerPluginCheck("plugin-system", async () => {
+        const start = Date.now();
+        const configured = lastConfiguredPluginsCount;
+        const loaded = loadedPlugins.size;
+        const status = configured === loaded ? "ok" : loaded > 0 ? "degraded" : "unhealthy";
+        return {
+          name: "plugin-system",
+          status,
+          durationMs: Date.now() - start,
+          details: {
+            configured,
+            loaded,
+            failures: pluginLoadFailures.slice(-10)
+          }
+        };
+      });
+      healthCheckRegistered = true;
+    }
+    for (const { capability, serviceKey } of CAPABILITY_BACKED_CONTRACTS) {
+      const providersForCapability = capabilitiesRegistry.get(capability) ?? /* @__PURE__ */ new Set();
+      for (const provider of providersForCapability) {
+        if (!loadedPlugins.has(provider)) continue;
+        const svcProviders = servicesRegistry.get(serviceKey);
+        if (!svcProviders || !svcProviders.has(provider)) {
+          contractErrors.push(
+            `Plugin ${provider} declares capability '${capability}' but did not register required service '${serviceKey}'.`
+          );
+          logger.error(
+            `Plugin ${provider} declares capability '${capability}' but did not register required service '${serviceKey}'.`
+          );
+        }
+      }
+    }
+    for (const loaded of loadedPlugins.values()) {
+      const plugin = Array.from(pluginData.values()).find((d) => d.plugin.name === loaded.name)?.plugin;
+      if (plugin && plugin.requiresCapabilities) {
+        for (const req of plugin.requiresCapabilities) {
+          if (!hasCapability(req)) {
+            const available = Array.from(capabilitiesRegistry.keys()).sort();
+            contractErrors.push(
+              `Plugin ${loaded.name} requires capability '${req}' which is not provided by any loaded plugin.`
+            );
+            logger.error(
+              `Plugin ${loaded.name} requires capability '${req}' which is not provided by any loaded plugin. Available capabilities: ${available.length ? available.join(", ") : "(none)"}`
+            );
+          }
+        }
+      }
+    }
+    for (const loaded of loadedPlugins.values()) {
+      const plugin = Array.from(pluginData.values()).find((d) => d.plugin.name === loaded.name)?.plugin;
+      if (!plugin?.requiresCapabilities) continue;
+      for (const { capability, serviceKey } of CAPABILITY_BACKED_CONTRACTS) {
+        if (!plugin.requiresCapabilities.includes(capability)) continue;
+        const activeProviders = getActiveProvidersForService(serviceKey);
+        if (activeProviders.size === 0) {
+          contractErrors.push(
+            `Plugin ${loaded.name} requires capability '${capability}' but no provider registered service '${serviceKey}'.`
+          );
+          logger.error(
+            `Plugin ${loaded.name} requires capability '${capability}' but no provider registered service '${serviceKey}'.`
+          );
+        }
+      }
+    }
+    if (failOnContractErrors && contractErrors.length > 0) {
+      throw new Error(
+        `Plugin contract errors detected (failOnContractErrors=true):
+- ${contractErrors.join("\n- ")}`
+      );
+    }
+  }
+  function getLoadedPlugins() {
+    return Array.from(loadedPlugins.values());
+  }
+  function getPluginLoadFailures() {
+    return [...pluginLoadFailures];
+  }
+  function getPluginTags() {
+    return Array.from(loadedPlugins.keys());
+  }
+  async function shutdown() {
+    for (const hook of shutdownHooks) {
+      try {
+        await hook();
+      } catch (err) {
+        logger.warn(`Plugin shutdown hook failed: ${err.message}`);
+      }
+    }
+  }
+  return {
+    loadPlugin,
+    loadAll,
+    getLoadedPlugins,
+    getPluginLoadFailures,
+    getPluginTags,
+    enqueue: enqueueDelegate,
+    shutdown
+  };
+}
+
+export {
+  createLimitedConcurrencyTaskQueue,
+  createMemoryTaskQueue,
+  validatePluginSchema,
+  validatePluginConfig,
+  importPluginModuleFromSpecifier,
+  createPluginSystem
+};