0xray 2.1.4 → 2.2.1

package/dist/mcps/knowledge-skills/strategist.server.js

@@ -1,5 +1,6 @@
 import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import { pluginRegistry } from "../../nucleus/plugin-registry.js";
 import * as path from "path";
 import { fileURLToPath } from "url";
 class StrategistServer extends XrayKnowledgeSkillBase {
@@ -75,6 +76,15 @@ class StrategistServer extends XrayKnowledgeSkillBase {
             architecture_review: async (args) => this.handleArchitectureReview(args),
         };
         this.setupToolHandlers();
+        pluginRegistry.registerToolPlugin({
+            name: "xray/strategist",
+            callTool: async (toolName, args) => {
+                const handler = this.handlers[toolName];
+                if (!handler)
+                    throw new Error(`Unknown tool: ${toolName}`);
+                return handler(args);
+            },
+        });
     }
     async handleStrategicGuidance(args) {
         const { context, options = [], criteria = [] } = args;

package/dist/mcps/knowledge-skills/tech-writer.server.js

@@ -6,6 +6,7 @@
  */
 import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import { pluginRegistry } from "../../nucleus/plugin-registry.js";
 import * as fs from "fs";
 import * as path from "path";
 class XrayDocumentationGenerationServer extends XrayKnowledgeSkillBase {
@@ -75,6 +76,15 @@ class XrayDocumentationGenerationServer extends XrayKnowledgeSkillBase {
             "generate_readme": async (args) => this.generateReadme(args),
         };
         this.setupToolHandlers();
+        pluginRegistry.registerToolPlugin({
+            name: "documentation-generation",
+            callTool: async (toolName, args) => {
+                const handler = this.handlers[toolName];
+                if (!handler)
+                    throw new Error(`Unknown tool: ${toolName}`);
+                return handler(args);
+            },
+        });
     }
     async analyzeDocumentation(args) {
         const { docsPath, codePath, docTypes = ["readme", "api", "code"] } = args;
@@ -585,7 +595,7 @@ class XrayDocumentationGenerationServer extends XrayKnowledgeSkillBase {
             openapi: "3.0.0",
             info: {
                 title: "API Documentation",
-                version: "2.1.3",
+                version: "2.2.0",
                 description: "Generated API documentation",
             },
             servers: [

package/dist/mcps/knowledge-skills/testing-strategy.server.js

@@ -8,6 +8,7 @@ import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import { pluginRegistry } from "../../nucleus/plugin-registry.js";
 import { detectProjectLanguage, LANGUAGE_CONFIGS, } from "../../utils/language-detector.js";
 class XrayTestingStrategyServer extends XrayKnowledgeSkillBase {
     constructor() {
@@ -91,6 +92,15 @@ class XrayTestingStrategyServer extends XrayKnowledgeSkillBase {
             "generate-test-file": async (args) => this.generateTestFile(args),
         };
         this.setupToolHandlers();
+        pluginRegistry.registerToolPlugin({
+            name: "testing-strategy",
+            callTool: async (toolName, args) => {
+                const handler = this.handlers[toolName];
+                if (!handler)
+                    throw new Error(`Unknown tool: ${toolName}`);
+                return handler(args);
+            },
+        });
     }
     async analyzeTestCoverage(args) {
         const { projectRoot, includeBreakdown = true, coverageThreshold = 80, } = args;

package/dist/mcps/knowledge-skills/ui-ux-design.server.js

@@ -6,6 +6,7 @@
  */
 import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import { pluginRegistry } from "../../nucleus/plugin-registry.js";
 class XrayUIUXDesignServer extends XrayKnowledgeSkillBase {
     constructor() {
         super("ui-ux-design", "2.0.1");
@@ -100,6 +101,15 @@ class XrayUIUXDesignServer extends XrayKnowledgeSkillBase {
             "analyze_visual_hierarchy": async (args) => this.analyzeVisualHierarchy(args),
         };
         this.setupToolHandlers();
+        pluginRegistry.registerToolPlugin({
+            name: "ui-ux-design",
+            callTool: async (toolName, args) => {
+                const handler = this.handlers[toolName];
+                if (!handler)
+                    throw new Error(`Unknown tool: ${toolName}`);
+                return handler(args);
+            },
+        });
     }
     async analyzeUIComponent(args) {
         const { componentCode, framework, checkAccessibility = true, checkResponsive = true, } = args;

package/dist/mcps/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
   "sources": [
     {

package/dist/mcps/simulation/server-simulations.js

@@ -79,7 +79,7 @@ export const frameworkHelpSimulations = {
                 type: 'text',
                 text: `**0xRay Framework Capabilities:**
 
-**42 Specialized Agents:**
+**41 Specialized Agents:**
 - enforcer: Codex compliance & error prevention
 - architect: System design & technical decisions
 - orchestrator: Multi-agent workflow coordination

package/dist/metrics/agent-metrics.d.ts

@@ -18,7 +18,8 @@ export interface AgentInvocation {
     metadata: Record<string, unknown> | undefined;
 }
 export type AgentType = "architect" | "code-analyzer" | "code-reviewer" | "researcher" | "frontend-engineer" | "backend-engineer" | "devops-engineer" | "security-auditor" | "database-engineer" | "testing-lead" | "performance-engineer" | "refactorer" | "bug-triage-specialist" | "strategist" | "tech-writer" | "content-creator" | "seo-consultant" | "growth-strategist" | "log-monitor" | "multimodal-looker" | "mobile-developer" | "frontend-ui-ux-engineer" | "custom" | "unknown";
-export type ComplexityLevel = "simple" | "moderate" | "complex" | "enterprise";
+import type { ComplexityLevel } from "../delegation/complexity-core.js";
+export type { ComplexityLevel };
 export interface AgentInvocationSummary {
     agentName: string;
     totalInvocations: number;

package/dist/nucleus/govern-http.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Nucleus HTTP Adapter — semantic convenience surface (Phase 0)
+ *
+ * IMPORTANT: MCP is the new standard (just as Dynamo is the established standard
+ * for the external governance signal). The canonical way for agents to call the
+ * nucleus is the first-class MCP tools (`govern_proposals`, `govern_reflection`)
+ * exposed by the governance MCP server (which already supports stdio + Streamable
+ * HTTP transport on /mcp and already delegates to the same GovernanceService).
+ *
+ * This module provides the *direct semantic convenience adapter*:
+ * - Pure `handleGovernRequest(body)` → returns the raw GovernanceResponse object.
+ * - Optional tiny Express app with `POST /govern` (and /health).
+ * - No full MCP JSON-RPC protocol overhead — ideal for curl, CI, simple bridges,
+ *   or anything that just wants the decision without speaking MCP.
+ *
+ * It reuses the exact same kernel (getGovernanceService + types) as the MCP path.
+ * Zero impact on the federation or existing MCP surfaces.
+ *
+ * Design goals:
+ * - Framework-agnostic pure handler (usable by Express, Fastify, raw http, tests, or in-process).
+ * - Only frameworkLogger.
+ * - Follows the thin-wrapper style of APITrigger.
+ *
+ * Usage (embeddable / in-process):
+ *   import { handleGovernRequest } from './nucleus/govern-http.js';
+ *   const result = await handleGovernRequest(req.body);
+ *
+ * Usage (standalone):
+ *   NUCLEUS_PORT=8787 node dist/nucleus/govern-http.js
+ */
+import express from 'express';
+import type { GovernanceResponse } from '../governance/governance-types.js';
+export interface GovernHTTPConfig {
+    path?: string;
+    apiKey?: string;
+    enabled?: boolean;
+    port?: number;
+}
+/**
+ * Pure handler. Can be used by any HTTP server (Express, Fastify, raw http, etc.)
+ * or called directly in tests / in-process.
+ */
+export declare function handleGovernRequest(body: unknown, options?: {
+    requireExternalDynamo?: boolean;
+}): Promise<GovernanceResponse>;
+/**
+ * Minimal Express app (prototype only).
+ * Mirrors the shape and logging discipline of APITrigger.
+ */
+export declare class GovernHTTPAdapter {
+    private app;
+    private config;
+    private initialized;
+    constructor(config?: GovernHTTPConfig);
+    initialize(): Promise<void>;
+    getApp(): express.Application;
+    listen(): Promise<void>;
+    shutdown(): void;
+}

package/dist/nucleus/govern-http.js

@@ -0,0 +1,172 @@
+/**
+ * Nucleus HTTP Adapter — semantic convenience surface (Phase 0)
+ *
+ * IMPORTANT: MCP is the new standard (just as Dynamo is the established standard
+ * for the external governance signal). The canonical way for agents to call the
+ * nucleus is the first-class MCP tools (`govern_proposals`, `govern_reflection`)
+ * exposed by the governance MCP server (which already supports stdio + Streamable
+ * HTTP transport on /mcp and already delegates to the same GovernanceService).
+ *
+ * This module provides the *direct semantic convenience adapter*:
+ * - Pure `handleGovernRequest(body)` → returns the raw GovernanceResponse object.
+ * - Optional tiny Express app with `POST /govern` (and /health).
+ * - No full MCP JSON-RPC protocol overhead — ideal for curl, CI, simple bridges,
+ *   or anything that just wants the decision without speaking MCP.
+ *
+ * It reuses the exact same kernel (getGovernanceService + types) as the MCP path.
+ * Zero impact on the federation or existing MCP surfaces.
+ *
+ * Design goals:
+ * - Framework-agnostic pure handler (usable by Express, Fastify, raw http, tests, or in-process).
+ * - Only frameworkLogger.
+ * - Follows the thin-wrapper style of APITrigger.
+ *
+ * Usage (embeddable / in-process):
+ *   import { handleGovernRequest } from './nucleus/govern-http.js';
+ *   const result = await handleGovernRequest(req.body);
+ *
+ * Usage (standalone):
+ *   NUCLEUS_PORT=8787 node dist/nucleus/govern-http.js
+ */
+import express from 'express';
+import { getGovernanceService } from '../governance/governance-service.js';
+import { frameworkLogger } from '../core/framework-logger.js';
+const DEFAULT_PATH = '/govern';
+/**
+ * Pure handler. Can be used by any HTTP server (Express, Fastify, raw http, etc.)
+ * or called directly in tests / in-process.
+ */
+export async function handleGovernRequest(body, options) {
+    const request = body;
+    if (!request || !Array.isArray(request.proposals)) {
+        throw new Error('Invalid governance request: "proposals" array is required');
+    }
+    const svc = getGovernanceService();
+    // Merge caller options into the request options (prototype only — keeps surface tiny)
+    const mergedOptions = {};
+    if (request.options?.requireExternalDynamo !== undefined) {
+        mergedOptions.requireExternalDynamo = request.options.requireExternalDynamo;
+    }
+    if (options?.requireExternalDynamo !== undefined) {
+        mergedOptions.requireExternalDynamo = options.requireExternalDynamo;
+    }
+    const mergedRequest = {
+        ...request,
+        options: mergedOptions,
+    };
+    await frameworkLogger.log('nucleus-http', 'govern-request-received', 'info', {
+        proposalCount: mergedRequest.proposals.length,
+        hasContext: !!mergedRequest.context,
+        path: DEFAULT_PATH,
+    });
+    const response = await svc.govern(mergedRequest);
+    await frameworkLogger.log('nucleus-http', 'govern-response', 'success', {
+        overallDecision: response.overallDecision,
+        total: response.summary.total,
+        approved: response.summary.approved,
+        rejected: response.summary.rejected,
+    });
+    return response;
+}
+/* c8 ignore start -- adapter + auto-run are integration-level (tested in later slices / E2E) */
+/**
+ * Minimal Express app (prototype only).
+ * Mirrors the shape and logging discipline of APITrigger.
+ */
+export class GovernHTTPAdapter {
+    app;
+    config;
+    initialized = false;
+    constructor(config = {}) {
+        this.config = {
+            enabled: true,
+            path: DEFAULT_PATH,
+            apiKey: '',
+            port: 8787,
+            ...config,
+        };
+        this.app = express();
+    }
+    async initialize() {
+        if (this.initialized || !this.config.enabled)
+            return;
+        this.app.use(express.json({ limit: '5mb' }));
+        // Optional API key (same pattern as APITrigger for early internal use)
+        if (this.config.apiKey) {
+            this.app.use((req, res, next) => {
+                const key = req.headers['x-api-key'];
+                if (!key || key !== this.config.apiKey) {
+                    res.status(403).json({ error: 'Invalid or missing API key' });
+                    return;
+                }
+                next();
+            });
+        }
+        const governPath = this.config.path;
+        // The direct semantic /govern endpoint (convenience, not the MCP standard surface).
+        // Agents that speak MCP should use the governance MCP server's tools (or its /mcp endpoint).
+        this.app.post(governPath, async (req, res) => {
+            try {
+                const result = await handleGovernRequest(req.body);
+                res.status(200).json(result);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                await frameworkLogger.log('nucleus-http', 'govern-error', 'error', { message });
+                res.status(400).json({
+                    error: 'Governance request failed',
+                    message,
+                    overallDecision: 'reject',
+                });
+            }
+        });
+        // Tiny health surface (useful for the verification loop later)
+        this.app.get(governPath + '/health', (_req, res) => {
+            res.json({
+                status: 'ok',
+                surface: 'nucleus-http',
+                version: 'v3-prototype',
+                endpoint: governPath,
+                timestamp: new Date().toISOString(),
+            });
+        });
+        this.initialized = true;
+        await frameworkLogger.log('nucleus-http', 'adapter-initialized', 'success', {
+            path: governPath,
+            port: this.config.port,
+            apiKeyProtected: !!this.config.apiKey,
+        });
+    }
+    getApp() {
+        return this.app;
+    }
+    async listen() {
+        await this.initialize();
+        const port = this.config.port;
+        this.app.listen(port, () => {
+            // We intentionally use frameworkLogger here too; the listen callback is the one place
+            // a startup banner is acceptable if we ever add a structured one. For now the log above suffices.
+            void frameworkLogger.log('nucleus-http', 'listening', 'success', { port, path: this.config.path });
+        });
+    }
+    shutdown() {
+        this.initialized = false;
+    }
+}
+// Allow direct execution for the absolute smallest validation loop:
+//   node --loader ts-node/esm src/nucleus/govern-http.ts
+// (or after build: node dist/nucleus/govern-http.js)
+if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith('govern-http.ts')) {
+    const adapter = new GovernHTTPAdapter({
+        port: Number(process.env.NUCLEUS_PORT || 8787),
+        path: process.env.NUCLEUS_PATH || DEFAULT_PATH,
+    });
+    // Fire and forget — the listen method logs via frameworkLogger
+    void adapter.listen().catch(async (err) => {
+        await frameworkLogger.log('nucleus-http', 'listen-failed', 'error', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        process.exit(1);
+    });
+}
+/* c8 ignore stop */

package/dist/nucleus/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * xray Nucleus — barrel export
+ *
+ * Import from here for the stable nucleus surface:
+ *   import { handleGovernRequest, governSingle } from './nucleus/index.js';
+ */
+export { handleGovernRequest, governSingle, getGovernanceService, GovernHTTPAdapter, NUCLEUS_VERSION, NUCLEUS_DESCRIPTION, } from './kernel.js';
+export type { GovernHTTPConfig } from './govern-http.js';
+export type { GovernanceRequest, GovernanceResponse, GovernanceProposal, GovernanceVote, GovernanceResult, GovernanceContext, GovernOptions, ProposalType, } from '../governance/governance-types.js';
+export type { MetamorphosisEngine, MetamorphosisProposal, } from '../postprocessor/metamorphosis/MetamorphosisEngine.js';
+export { SelfProposalEngine, } from '../postprocessor/metamorphosis/SelfProposalEngine.js';
+export type { SelfProposalConfig, } from '../postprocessor/metamorphosis/SelfProposalEngine.js';
+export { pluginRegistry, } from './plugin-registry.js';
+export type { SkillPlugin, SkillToolPlugin, SkillProposalArgs, SkillPluginResult, } from './plugin-registry.js';

package/dist/nucleus/index.js

@@ -0,0 +1,9 @@
+/**
+ * xray Nucleus — barrel export
+ *
+ * Import from here for the stable nucleus surface:
+ *   import { handleGovernRequest, governSingle } from './nucleus/index.js';
+ */
+export { handleGovernRequest, governSingle, getGovernanceService, GovernHTTPAdapter, NUCLEUS_VERSION, NUCLEUS_DESCRIPTION, } from './kernel.js';
+export { SelfProposalEngine, } from '../postprocessor/metamorphosis/SelfProposalEngine.js';
+export { pluginRegistry, } from './plugin-registry.js';

package/dist/nucleus/kernel.d.ts

@@ -0,0 +1,51 @@
+/**
+ * xray Nucleus — the callable governance kernel (Phase 1.1 facade)
+ *
+ * This is the primary, stable import surface for the v3 nucleus.
+ *
+ * Consumers (bridges, custom tools, the MCP governance server, future self-proposal
+ * engines, CLI, etc.) should import from here rather than reaching into
+ * governance-service.ts, govern-http.ts, or postprocessor internals directly.
+ *
+ * Goals:
+ * - Single place to import the core "govern" capability + supporting types.
+ * - Zero risk to the 41-server federation or existing bridges.
+ * - Easy to tree-shake / split later (e.g. "nucleus/core", "nucleus/http").
+ * - Documents the public kernel contract.
+ *
+ * Current surface (Phase 1.1):
+ * - handleGovernRequest: the pure semantic convenience handler (direct JSON in/out)
+ * - getGovernanceService: the underlying singleton (for advanced / in-process use)
+ * - Governance types
+ * - MetamorphosisEngine interface (for PostProcessor lifecycle integration)
+ *
+ * MCP remains the canonical standard surface (see governance.server.ts).
+ * The direct HTTP adapter (govern-http.ts) is a convenience on top of this kernel.
+ *
+ * Anti-goals (for this file):
+ * - No new business logic
+ * - No side effects on import
+ * - Does not pull in the full 25 knowledge-skill servers (dynamic via pluginRegistry only)
+ */
+import type { GovernOptions, GovernanceContext, GovernanceRequest, GovernanceResponse } from '../governance/governance-types.js';
+import { handleGovernRequest } from './govern-http.js';
+export { handleGovernRequest };
+export type { GovernHTTPConfig } from './govern-http.js';
+export { getGovernanceService } from '../governance/governance-service.js';
+export type { GovernanceRequest, GovernanceResponse, GovernanceProposal, GovernanceVote, GovernanceResult, GovernanceContext, GovernOptions, ProposalType, } from '../governance/governance-types.js';
+export type { MetamorphosisEngine, MetamorphosisProposal, } from '../postprocessor/metamorphosis/MetamorphosisEngine.js';
+export { GovernHTTPAdapter } from './govern-http.js';
+export { pluginRegistry } from './plugin-registry.js';
+export type { SkillPlugin, SkillToolPlugin, SkillProposalArgs, SkillPluginResult } from './plugin-registry.js';
+/**
+ * High-level kernel description for introspection / docs.
+ */
+export declare const NUCLEUS_VERSION = "0.1.0";
+export declare const NUCLEUS_DESCRIPTION: string;
+/**
+ * Quick helper for the common case: govern a single proposal and get the overall decision.
+ * (Thin wrapper — real power users should use handleGovernRequest directly for batch + full response.)
+ */
+export declare function governSingle(proposal: Omit<GovernanceRequest['proposals'][0], 'id'> & {
+    id?: string;
+}, context?: GovernanceContext, options?: GovernOptions): Promise<GovernanceResponse>;

package/dist/nucleus/kernel.js

@@ -0,0 +1,62 @@
+/**
+ * xray Nucleus — the callable governance kernel (Phase 1.1 facade)
+ *
+ * This is the primary, stable import surface for the v3 nucleus.
+ *
+ * Consumers (bridges, custom tools, the MCP governance server, future self-proposal
+ * engines, CLI, etc.) should import from here rather than reaching into
+ * governance-service.ts, govern-http.ts, or postprocessor internals directly.
+ *
+ * Goals:
+ * - Single place to import the core "govern" capability + supporting types.
+ * - Zero risk to the 41-server federation or existing bridges.
+ * - Easy to tree-shake / split later (e.g. "nucleus/core", "nucleus/http").
+ * - Documents the public kernel contract.
+ *
+ * Current surface (Phase 1.1):
+ * - handleGovernRequest: the pure semantic convenience handler (direct JSON in/out)
+ * - getGovernanceService: the underlying singleton (for advanced / in-process use)
+ * - Governance types
+ * - MetamorphosisEngine interface (for PostProcessor lifecycle integration)
+ *
+ * MCP remains the canonical standard surface (see governance.server.ts).
+ * The direct HTTP adapter (govern-http.ts) is a convenience on top of this kernel.
+ *
+ * Anti-goals (for this file):
+ * - No new business logic
+ * - No side effects on import
+ * - Does not pull in the full 25 knowledge-skill servers (dynamic via pluginRegistry only)
+ */
+import { handleGovernRequest } from './govern-http.js';
+// Re-export the pure handler (the main "call the nucleus" entry point)
+export { handleGovernRequest };
+// Re-export the canonical way to obtain the service (used by MCP, internal code, and advanced callers)
+export { getGovernanceService } from '../governance/governance-service.js';
+// Convenience re-export of the HTTP adapter for anyone who wants the tiny Express wrapper
+// (still considered "convenience", not core kernel)
+export { GovernHTTPAdapter } from './govern-http.js';
+// Plugin registry — dynamic skill and tool dispatch
+export { pluginRegistry } from './plugin-registry.js';
+/**
+ * High-level kernel description for introspection / docs.
+ */
+export const NUCLEUS_VERSION = '0.1.0'; // Phase 1 facade version
+export const NUCLEUS_DESCRIPTION = 'xray governance kernel — external Dynamo signal + 3-agent deliberation exposed as a callable library. ' +
+    'MCP is the standard surface; direct handleGovernRequest + HTTP adapter are convenience paths.';
+/**
+ * Quick helper for the common case: govern a single proposal and get the overall decision.
+ * (Thin wrapper — real power users should use handleGovernRequest directly for batch + full response.)
+ */
+export async function governSingle(proposal, context, options) {
+    const fullRequest = {
+        proposals: [
+            {
+                id: proposal.id || `prop-${Date.now()}`,
+                ...proposal,
+            },
+        ],
+        context,
+        ...(options ? { options } : {}),
+    };
+    return handleGovernRequest(fullRequest);
+}

package/dist/nucleus/plugin-registry.d.ts

@@ -0,0 +1,104 @@
+/**
+ * PluginRegistry — Phase 1.2 dynamic skill loading + Phase 3 generic tool dispatch
+ *
+ * Allows skills to be registered after boot, loaded from config, or discovered
+ * at runtime. Wraps the existing in-process-skill-registry for backward compat.
+ *
+ * Phase 3 extension: SkillToolPlugin interface for multi-tool skills (knowledge-skill
+ * servers). Each server registers as a SkillToolPlugin, exposing arbitrary tools
+ * that can be dispatched via callSkillTool().
+ *
+ * Goals:
+ * - New skills can be registered post-boot via register()
+ * - Skills are discoverable by name without importing server constructors
+ * - Default set loads automatically from the existing 3 governance skills
+ * - Multi-tool skills can be registered and dispatched via callSkillTool()
+ * - Backward compatible: callInProcessSkill still works as before
+ */
+export interface SkillPlugin {
+    /** Unique skill name (e.g. "code-review", "security-audit") */
+    name: string;
+    /** Handler that processes proposals */
+    analyzeProposal(args: SkillProposalArgs): Promise<SkillPluginResult>;
+}
+/**
+ * Extended plugin interface for knowledge-skill servers that expose multiple tools.
+ * Each tool is a named function that accepts arbitrary args.
+ */
+export interface SkillToolPlugin {
+    /** Unique skill name (e.g. "code-review", "api-design") */
+    name: string;
+    /** Dispatch a named tool with arbitrary args */
+    callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+}
+export interface SkillProposalArgs {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    evidence?: string[];
+    proposalType?: string;
+}
+export interface SkillPluginResult {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+}
+type SkillHandler = (args: SkillProposalArgs) => Promise<SkillPluginResult>;
+declare class PluginRegistryImpl {
+    private skills;
+    /** Phase 3: multi-tool skill plugins (knowledge-skill servers) */
+    private toolPlugins;
+    private initialized;
+    /**
+     * Register a skill plugin. Can be called after boot.
+     */
+    register(skill: SkillPlugin): void;
+    /**
+     * Register a multi-tool skill plugin (knowledge-skill server).
+     * Tools can be dispatched via callSkillTool().
+     */
+    registerToolPlugin(skill: SkillToolPlugin): void;
+    /**
+     * Call a named tool on a registered multi-tool skill plugin.
+     */
+    callSkillTool(skillName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Check if a tool plugin is registered.
+     */
+    hasToolPlugin(name: string): boolean;
+    /**
+     * List all registered tool plugin names.
+     */
+    listToolPlugins(): string[];
+    /**
+     * Get a skill handler by name. Falls back to the in-process registry
+     * for the built-in governance skills (code-review, security-audit, researcher).
+     */
+    get(name: string): SkillHandler | undefined;
+    /**
+     * Check if a skill is registered (either in the plugin registry or the built-in registry).
+     */
+    has(name: string): boolean;
+    /**
+     * List all registered skill names (plugins + built-in).
+     */
+    list(): string[];
+    /**
+     * Call a skill by name. Delegates to the plugin registry first,
+     * then falls back to the built-in in-process registry.
+     */
+    callSkill(name: string, args: SkillProposalArgs): Promise<SkillPluginResult>;
+    /**
+     * Initialize with default governance skills. Called once at boot.
+     * The 3 governance skills are always available via the built-in registry.
+     */
+    initializeDefaults(): void;
+    /**
+     * Reset the registry for testing. Removes all registered plugins
+     * (built-in governance skills remain available via fallback).
+     */
+    resetForTest(): void;
+}
+/** Singleton plugin registry */
+export declare const pluginRegistry: PluginRegistryImpl;
+export {};