0xray 2.1.4 → 2.2.0

package/dist/postprocessor/metamorphosis/SelfProposalEngine.js

@@ -0,0 +1,371 @@
+/**
+ * SelfProposalEngine — Phase 2.2
+ *
+ * Concrete MetamorphosisEngine that reads activity.log, parses structured
+ * log entries, detects semantic patterns, generates governance proposals
+ * (type: 'metamorphosis'), and submits them through the full 3-agent +
+ * Dynamo governance pipeline.
+ *
+ * Safety constraints:
+ * - Max proposals per hour (default 1, configurable)
+ * - Circuit breaker: after N consecutive failures, halt for cooldown (default 3/24h)
+ * - Only proposes changes to whitelisted targets
+ * - All proposals go through full governance with metamorphosisThreshold (default 0.7)
+ * - Detection thresholds are configurable (not hard-coded)
+ *
+ * Coupling note: currently triggered by PostProcessor.onPhase(). A future
+ * refactor should extract log-reading into a dedicated LogReader that can
+ * run on its own schedule or fs.watch, decoupling from PostProcessor lifecycle.
+ */
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { handleGovernRequest } from '../../nucleus/govern-http.js';
+const DEFAULT_CONFIG = {
+    maxProposalsPerHour: 1,
+    circuitBreakerThreshold: 3,
+    circuitBreakerCooldownHours: 24,
+    activityLogPath: 'logs/framework/activity.log',
+    whitelistedTargets: ['config/', 'features.json', 'src/processors/'],
+    maxLogLines: 100,
+    errorThreshold: 5,
+    warningThreshold: 10,
+    governanceRejectionThreshold: 3,
+    proposalConfidence: 0.7,
+    metamorphosisThreshold: 0.7,
+    projectRoot: process.cwd(),
+};
+const LOG_LINE_PATTERN = /^(\d{4}-\d{2}-\d{2}T[^ ]+)\s+(?:\[([^\]]*)\]\s+)?(?:\[([^\]]*)\]\s+)?\[([^\]]*)\]\s+(\S+)\s+-\s+(\w+)(?:\s+\|(.+))?$/;
+function parseLogEntry(line) {
+    const match = line.match(LOG_LINE_PATTERN);
+    if (!match) {
+        // Fallback: try JSON parse for entangled log entries
+        try {
+            const json = JSON.parse(line);
+            if (json && typeof json === 'object' && json.action) {
+                return {
+                    timestamp: json.timestamp ? new Date(json.timestamp).toISOString() : new Date().toISOString(),
+                    component: json.component || 'unknown',
+                    action: json.action,
+                    status: (json.status || json.level || 'info').toLowerCase(),
+                    details: json.details || json,
+                    raw: line,
+                };
+            }
+        }
+        catch { }
+        return null;
+    }
+    const [, timestamp, , , component, action, status, detailsStr] = match;
+    let details;
+    if (detailsStr) {
+        try {
+            details = JSON.parse(detailsStr.trim());
+        }
+        catch {
+            details = { rawDetails: detailsStr.trim() };
+        }
+    }
+    const entry = {
+        timestamp: timestamp ?? new Date().toISOString(),
+        component: component || 'unknown',
+        action: action ?? 'unknown',
+        status: (status ?? 'info').toLowerCase(),
+        raw: line,
+    };
+    if (details !== undefined) {
+        entry.details = details;
+    }
+    return entry;
+}
+export class SelfProposalEngine {
+    name = 'self-proposal';
+    config;
+    proposalHistory = [];
+    consecutiveFailures = 0;
+    circuitBreakerUntil = 0;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    async onPhase(phase, context) {
+        if (phase !== 'monitoring-complete' && phase !== 'post-process-complete') {
+            return;
+        }
+        await frameworkLogger.log('self-proposal', 'phase-hook', 'info', {
+            phase,
+            message: 'Self-proposal engine triggered by phase',
+        });
+        if (this.isCircuitBreakerActive()) {
+            await frameworkLogger.log('self-proposal', 'circuit-breaker-active', 'warning', {
+                message: `Circuit breaker active until ${new Date(this.circuitBreakerUntil).toISOString()}`,
+                consecutiveFailures: this.consecutiveFailures,
+            });
+            return;
+        }
+        if (this.isRateLimited()) {
+            await frameworkLogger.log('self-proposal', 'rate-limited', 'info', {
+                message: 'Max proposals per hour reached',
+            });
+            return;
+        }
+        await this.evaluateAndPropose();
+    }
+    async onProposal(proposal) {
+        await frameworkLogger.log('self-proposal', 'external-proposal', 'info', {
+            proposalId: proposal.id,
+            type: proposal.type,
+            target: proposal.target,
+            impact: proposal.impact,
+        });
+    }
+    isCircuitBreakerActive() {
+        if (this.consecutiveFailures >= this.config.circuitBreakerThreshold) {
+            if (Date.now() < this.circuitBreakerUntil) {
+                return true;
+            }
+            this.consecutiveFailures = 0;
+            this.circuitBreakerUntil = 0;
+        }
+        return false;
+    }
+    isRateLimited() {
+        const oneHourAgo = Date.now() - 60 * 60 * 1000;
+        const recentProposals = this.proposalHistory.filter(a => a.timestamp > oneHourAgo);
+        return recentProposals.length >= this.config.maxProposalsPerHour;
+    }
+    async evaluateAndPropose() {
+        let logEntries = [];
+        try {
+            const logContent = await fs.readFile(this.config.activityLogPath, 'utf-8');
+            const lines = logContent.trim().split('\n');
+            logEntries = lines.slice(-this.config.maxLogLines).filter(line => line.trim().length > 0);
+        }
+        catch {
+            await frameworkLogger.log('self-proposal', 'log-read-error', 'warning', {
+                path: this.config.activityLogPath,
+                message: 'Activity log not found or unreadable — skipping self-proposal',
+            });
+            return;
+        }
+        const patterns = this.detectPatterns(logEntries);
+        if (patterns.length === 0) {
+            await frameworkLogger.log('self-proposal', 'no-patterns', 'info', {
+                message: 'No actionable patterns detected in activity log',
+            });
+            return;
+        }
+        for (const pattern of patterns) {
+            await this.submitProposal(pattern);
+        }
+    }
+    /**
+     * Detect actionable patterns from parsed activity log entries.
+     * Uses structured parsing instead of raw string matching to handle
+     * the actual xray log format:
+     *   ISO_TIMESTAMP [jobId] [traceId.spanId] [component] action - STATUS | {details}
+     */
+    detectPatterns(entries) {
+        const parsed = entries.map(parseLogEntry).filter((e) => e !== null);
+        const proposals = [];
+        const errorEntries = parsed.filter(e => e.status === 'error');
+        const warningEntries = parsed.filter(e => e.status === 'warning');
+        const rejectedEntries = parsed.filter(e => e.component === 'governance' && (e.status === 'rejected' || e.details?.decision === 'reject'));
+        if (errorEntries.length >= this.config.errorThreshold) {
+            const components = [...new Set(errorEntries.map(e => e.component))];
+            proposals.push({
+                id: `meta-errors-${Date.now()}`,
+                type: 'modify',
+                target: 'config/error-handling',
+                description: `Elevated error rate: ${errorEntries.length} errors in last ${this.config.maxLogLines} entries. Components: ${components.join(', ')}. Propose adjusting error handling thresholds.`,
+                rationale: `High error count (${errorEntries.length}) across ${components.length} component(s) indicates a systemic issue. Affected components: ${components.join(', ')}. Governance review recommended for self-optimization.`,
+                impact: 'medium',
+            });
+        }
+        if (warningEntries.length >= this.config.warningThreshold) {
+            const components = [...new Set(warningEntries.map(e => e.component))];
+            proposals.push({
+                id: `meta-warnings-${Date.now()}`,
+                type: 'modify',
+                target: 'config/monitoring',
+                description: `Elevated warning rate: ${warningEntries.length} warnings in last ${this.config.maxLogLines} entries. Components: ${components.join(', ')}. Propose adjusting monitoring sensitivity.`,
+                rationale: `Frequent warnings (${warningEntries.length}) across ${components.length} component(s) may indicate configuration drift. Affected: ${components.join(', ')}.`,
+                impact: 'low',
+            });
+        }
+        if (rejectedEntries.length >= this.config.governanceRejectionThreshold) {
+            proposals.push({
+                id: `meta-governance-rejections-${Date.now()}`,
+                type: 'modify',
+                target: 'config/governance',
+                description: `Repeated governance rejections: ${rejectedEntries.length} in last ${this.config.maxLogLines} entries. Propose reviewing governance thresholds or submission patterns.`,
+                rationale: `${rejectedEntries.length} governance rejections suggest a pattern mismatch between proposals and governance criteria. Review recommended.`,
+                impact: 'medium',
+            });
+        }
+        return proposals.filter(p => this.config.whitelistedTargets.some(t => p.target.startsWith(t)));
+    }
+    /**
+     * Apply an approved self-evolution proposal by recording the change
+     * in a state file within the first matching whitelisted target directory.
+     * Returns true if the change was written and verified, false otherwise.
+     */
+    async applySelfProposal(pattern, score, decision) {
+        const matchedTarget = this.config.whitelistedTargets.find(t => pattern.target.startsWith(t));
+        if (!matchedTarget) {
+            await frameworkLogger.log('self-proposal', 'apply-no-matching-target', 'warning', {
+                proposalId: pattern.id,
+                target: pattern.target,
+                message: 'No whitelisted target matches this proposal — skipping apply',
+            });
+            return false;
+        }
+        const root = this.config.projectRoot;
+        const stateDir = join(root, matchedTarget);
+        const statePath = join(stateDir, 'self-evolution-state.json');
+        let applied = [];
+        try {
+            const content = await fs.readFile(statePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (Array.isArray(parsed.applied))
+                applied = parsed.applied;
+        }
+        catch { }
+        applied.push({
+            proposalId: pattern.id,
+            target: pattern.target,
+            type: pattern.type,
+            description: pattern.description,
+            rationale: pattern.rationale,
+            impact: pattern.impact,
+            metamorphosisScore: score,
+            decision: decision,
+            appliedAt: new Date().toISOString(),
+        });
+        try {
+            await fs.mkdir(stateDir, { recursive: true });
+            await fs.writeFile(statePath, JSON.stringify({ applied }, null, 2), 'utf-8');
+        }
+        catch (writeError) {
+            await frameworkLogger.log('self-proposal', 'apply-write-error', 'error', {
+                proposalId: pattern.id,
+                path: statePath,
+                error: writeError instanceof Error ? writeError.message : String(writeError),
+            });
+            return false;
+        }
+        try {
+            const verify = await fs.readFile(statePath, 'utf-8');
+            const parsed = JSON.parse(verify);
+            const found = Array.isArray(parsed.applied) && parsed.applied.some((a) => a.proposalId === pattern.id);
+            if (!found) {
+                await frameworkLogger.log('self-proposal', 'apply-verify-failed', 'error', {
+                    proposalId: pattern.id,
+                    message: 'Applied change not found in state file after write — verification failed',
+                });
+            }
+            return found;
+        }
+        catch (verifyError) {
+            await frameworkLogger.log('self-proposal', 'apply-verify-error', 'error', {
+                proposalId: pattern.id,
+                error: verifyError instanceof Error ? verifyError.message : String(verifyError),
+            });
+            return false;
+        }
+    }
+    async submitProposal(pattern) {
+        const governanceRequest = {
+            proposals: [{
+                    id: pattern.id,
+                    type: 'metamorphosis',
+                    title: `Self-proposal: ${pattern.description.slice(0, 80)}`,
+                    description: pattern.description,
+                    evidence: [pattern.rationale],
+                    source: 'metamorphosis',
+                    confidence: this.config.proposalConfidence,
+                }],
+            context: {
+                project: 'xray-self',
+                phase: 'self-evolution',
+                source: 'self-proposal-engine',
+            },
+            options: {
+                requireExternalDynamo: true,
+                metamorphosisThreshold: this.config.metamorphosisThreshold,
+            },
+        };
+        await frameworkLogger.log('self-proposal', 'submitting', 'info', {
+            proposalId: pattern.id,
+            target: pattern.target,
+            impact: pattern.impact,
+        });
+        try {
+            const response = await handleGovernRequest(governanceRequest);
+            const result = response.results[0];
+            if (!result) {
+                await frameworkLogger.log('self-proposal', 'no-result', 'warning', {
+                    proposalId: pattern.id,
+                    message: 'Governance returned no results',
+                });
+                return;
+            }
+            const decision = result.finalDecision;
+            const attempt = {
+                timestamp: Date.now(),
+                result: decision === 'approve' ? 'approved' : decision === 'reject' ? 'rejected' : 'needs_revision',
+            };
+            if (result.metamorphosisScore !== undefined) {
+                attempt.metamorphosisScore = result.metamorphosisScore;
+            }
+            this.proposalHistory.push(attempt);
+            if (decision === 'approve' && (result.metamorphosisScore ?? 0) >= this.config.metamorphosisThreshold) {
+                this.consecutiveFailures = 0;
+                await frameworkLogger.log('self-proposal', 'approved', 'success', {
+                    proposalId: pattern.id,
+                    metamorphosisScore: result.metamorphosisScore,
+                    message: 'Self-evolution proposal approved by governance — applying change',
+                });
+                const applied = await this.applySelfProposal(pattern, result.metamorphosisScore, decision);
+                if (applied) {
+                    await frameworkLogger.log('self-proposal', 'applied', 'success', {
+                        proposalId: pattern.id,
+                        target: pattern.target,
+                        message: 'Self-evolution change applied and verified',
+                    });
+                }
+                else {
+                    this.consecutiveFailures++;
+                    if (this.consecutiveFailures >= this.config.circuitBreakerThreshold) {
+                        this.circuitBreakerUntil = Date.now() + this.config.circuitBreakerCooldownHours * 60 * 60 * 1000;
+                    }
+                    await frameworkLogger.log('self-proposal', 'apply-failed', 'error', {
+                        proposalId: pattern.id,
+                        target: pattern.target,
+                        consecutiveFailures: this.consecutiveFailures,
+                        message: 'Self-evolution change apply failed — circuit breaker may activate',
+                    });
+                }
+            }
+            else {
+                this.consecutiveFailures++;
+                if (this.consecutiveFailures >= this.config.circuitBreakerThreshold) {
+                    this.circuitBreakerUntil = Date.now() + this.config.circuitBreakerCooldownHours * 60 * 60 * 1000;
+                }
+                await frameworkLogger.log('self-proposal', 'not-approved', 'warning', {
+                    proposalId: pattern.id,
+                    decision: decision,
+                    metamorphosisScore: result.metamorphosisScore,
+                    consecutiveFailures: this.consecutiveFailures,
+                    circuitBreakerUntil: this.circuitBreakerUntil || 'not active',
+                });
+            }
+        }
+        catch (error) {
+            this.consecutiveFailures++;
+            await frameworkLogger.log('self-proposal', 'submission-error', 'error', {
+                proposalId: pattern.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}

package/dist/skills/orchestrator/SKILL.md

@@ -15,7 +15,7 @@ dependencies: []
 mcp:
   orchestrator:
     command: node
-    args: [node_modules/0xray/dist/mcps/orchestrator.server.js]
+    args: [node_modules/0xray/dist/mcps/orchestrator/server.js]
 ---
 
 # Orchestrator Skill

package/dist/state/index.d.ts

@@ -1,3 +1 @@
 export { StateManager, XrayStateManager, XrayStateManager as StrRayStateManager } from "./state-manager.js";
-export type { StateValue, StateTypes } from "./state-types.js";
-export type { ContextProviders } from "./context-providers.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "2.1.4",
+  "version": "2.2.0",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "license": "MIT",
   "repository": {
@@ -58,10 +58,10 @@
     "test": "vitest run",
     "test:batch": "npm test",
     "test:unit": "npm test -- src/__tests__/unit/config-loader.test.ts src/__tests__/unit/state-manager.test.ts src/__tests__/unit/state-manager-persistence.test.ts src/__tests__/unit/context-loader.test.ts src/__tests__/unit/pattern-analyzer.test.ts src/__tests__/unit/complexity-calibrator.test.ts",
-    "test:core-framework": "npm test -- src/__tests__/unit/self-direction-activation.test.ts src/__tests__/unit/ast-code-parser.test.ts src/__tests__/unit/v2-deletion-protection.test.ts",
+    "test:core-framework": "npm test -- src/__tests__/unit/ast-code-parser.test.ts src/__tests__/unit/v2-deletion-protection.test.ts",
     "test:security": "npm test -- src/__tests__/unit/security/security-hardener.test.ts src/__tests__/unit/security/security-headers.test.ts",
     "test:performance": "npm test -- src/__tests__/unit/monitoring.test.ts src/__tests__/unit/benchmark.test.ts src/__tests__/unit/analytics.test.ts",
-    "test:session-management": "npm test -- src/__tests__/unit/session-state-manager.test.ts src/__tests__/unit/session-security-validator.test.ts src/__tests__/unit/session-coordination-validator.test.ts src/__tests__/unit/session-migration-validator.test.ts src/__tests__/unit/session-migration-logic.test.ts",
+    "test:session-management": "npm test -- src/__tests__/unit/session-state-manager.test.ts src/__tests__/unit/session-migration-logic.test.ts",
     "test:code-analysis": "npm test -- src/__tests__/unit/codebase-context-analyzer.test.ts src/__tests__/unit/dependency-graph-builder.test.ts src/__tests__/unit/rule-enforcer.test.ts src/__tests__/unit/codex-parser.test.ts src/__tests__/unit/codex-injector.test.ts",
     "test:processors": "npm test -- src/__tests__/unit/processor-activation.test.ts src/__tests__/unit/typescript-compilation-processor.test.ts",
     "test:miscellaneous": "npm test -- src/__tests__/unit/blocked-test.test.ts",
@@ -87,6 +87,7 @@
     "test:e2e": "node scripts/node/validate-mcp-connectivity.js && node scripts/node/validate-external-processes.js",
     "validate": "echo \"[xray] Use 'npm test' or 'npm run test:comprehensive'.\"",
     "validate:quick": "npm run validate",
+    "verify:consumer": "bash scripts/verify-consumer.sh",
     "debug:inference:force": "STRRAY_FORCE_MCP_GOVERNANCE=true XRAY_DEV_PATH=dist node dist/cli/index.js inference:run --force",
     "validate:full": "npm run validate",
     "test:unified": "node scripts/test/test-unified-framework.mjs",

package/scripts/node/universal-version-manager.js

@@ -155,9 +155,9 @@ const detectedCodex = detectCodexInfo();
 const OFFICIAL_VERSIONS = {
   // Framework version
   framework: {
-    version: "2.1.4",
+    version: "2.2.0",
       displayName: "xray: Self-Healing AI Governance OS",
-      lastUpdated: "2026-06-09",
+      lastUpdated: "2026-06-10",
     // Counts (auto-calculated, but can be overridden)
     ...CALCULATED_COUNTS,
   },

package/src/mcps/config/__tests__/server-config-registry.test.ts

@@ -166,45 +166,36 @@ describe('ServerConfigRegistry', () => {
 
     it('should use XRAY_DEV_PATH env var in dynamic config', () => {
       const originalXrayEnv = process.env.XRAY_DEV_PATH;
-      const originalStrrayEnv = ;
       process.env.XRAY_DEV_PATH = 'custom-dist';
-       = 'custom-dist';
-      
+
       const config = registry.createDynamicConfig('test-server');
       expect(config.args[0]).toContain('custom-dist');
-      
+
       process.env.XRAY_DEV_PATH = originalXrayEnv;
-       = originalStrrayEnv;
     });
   });
 
   describe('environment path handling', () => {
     it('should use resolved framework path when XRAY_DEV_PATH is not set', () => {
       const originalXrayEnv = process.env.XRAY_DEV_PATH;
-      const originalStrrayEnv = ;
       delete process.env.XRAY_DEV_PATH;
-      delete ;
-      
+
       const freshRegistry = new ServerConfigRegistry();
       const config = freshRegistry.get('code-review');
       expect(config?.args[0]).toContain('.server.js');
-      
+
       process.env.XRAY_DEV_PATH = originalXrayEnv;
-       = originalStrrayEnv;
     });
 
     it('should use XRAY_DEV_PATH when set', () => {
       const originalXrayEnv = process.env.XRAY_DEV_PATH;
-      const originalStrrayEnv = ;
       process.env.XRAY_DEV_PATH = 'dist';
-       = 'dist';
-      
+
       const freshRegistry = new ServerConfigRegistry();
       const config = freshRegistry.get('code-review');
       expect(config?.args[0]).toContain('dist/');
-      
+
       process.env.XRAY_DEV_PATH = originalXrayEnv;
-       = originalStrrayEnv;
     });
   });
 

package/src/mcps/config/server-config-registry.ts

@@ -180,7 +180,7 @@ export class ServerConfigRegistry {
     this.register({
       serverName: 'orchestrator',
       command: 'node',
-      args: [`${basePath}/orchestrator.server.js`],
+      args: [`${basePath}/orchestrator/server.js`],
       timeout: 60000,
     });
 

package/src/mcps/governance.server.ts

@@ -28,7 +28,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
 import { randomUUID } from "crypto";
-import { getGovernanceService } from "../governance/governance-service.js";
+import { handleGovernRequest } from "../nucleus/index.js";
 import { getCodexPolicyService } from "../governance/codex-policy.service.js";
 import { initializeGovernanceIntegration, shutdownGovernanceIntegration } from "../integrations/governance/index.js";
 import { featuresConfigLoader } from "../core/features-config.js";
@@ -243,8 +243,6 @@ class GovernanceServer {
   }
 
   private async handleGovernProposals(args: GovernProposalsArgs): Promise<CallToolResult> {
-    const service = getGovernanceService();
-
     const request: GovernanceRequest = {
       proposals: args.proposals.map((p, i) => ({
         id: p.id || `prop-${Date.now()}-${i}`,
@@ -261,11 +259,11 @@ class GovernanceServer {
       },
     };
 
-    frameworkLogger.log("governance-mcp", "delegating-to-governance-service", "info", {
+    frameworkLogger.log("governance-mcp", "delegating-to-kernel", "info", {
       proposalCount: request.proposals.length,
     });
 
-    const response = await service.govern(request);
+    const response = await handleGovernRequest(request);
 
     return {
       content: [

package/src/mcps/knowledge-skills/api-design.server.ts

@@ -7,6 +7,7 @@
 
 import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import { pluginRegistry } from "../../nucleus/plugin-registry.js";
 
 interface DesignApiEndpointsArgs {
   resource: string;
@@ -56,6 +57,14 @@ class XrayApiDesignServer extends XrayKnowledgeSkillBase {
       "validate-api-design": async (args) => this.validateApiDesign(args as unknown as ValidateApiDesignArgs),
     };
     this.setupToolHandlers();
+    pluginRegistry.registerToolPlugin({
+      name: "api-design",
+      callTool: async (toolName, args) => {
+        const handler = this.handlers[toolName];
+        if (!handler) throw new Error(`Unknown tool: ${toolName}`);
+        return handler(args);
+      },
+    });
   }
 
   private async designApiEndpoints(args: DesignApiEndpointsArgs) {

package/src/mcps/knowledge-skills/architecture-patterns.server.ts

@@ -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 fs from "fs";
 import * as path from "path";
 
@@ -49,6 +50,14 @@ class XrayArchitecturePatternsServer extends XrayKnowledgeSkillBase {
       "recommend-patterns": async (args) => this.recommendPatterns(args as unknown as RecommendPatternsArgs),
     };
     this.setupToolHandlers();
+    pluginRegistry.registerToolPlugin({
+      name: "architecture-patterns",
+      callTool: async (toolName, args) => {
+        const handler = this.handlers[toolName];
+        if (!handler) throw new Error(`Unknown tool: ${toolName}`);
+        return handler(args);
+      },
+    });
   }
 
   private async analyzeArchitecture(args: AnalyzeArchitectureArgs) {

package/src/mcps/knowledge-skills/bug-triage-specialist.server.ts

@@ -11,6 +11,7 @@ import * as path from "path";
 import { fileURLToPath } from "url";
 import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import { pluginRegistry } from "../../nucleus/plugin-registry.js";
 
 interface BugReport {
   id: string;
@@ -254,6 +255,14 @@ class BugTriageSpecialistServer extends XrayKnowledgeSkillBase {
       },
     };
     this.setupToolHandlers();
+    pluginRegistry.registerToolPlugin({
+      name: "bug-triage-specialist",
+      callTool: async (toolName, args) => {
+        const handler = this.handlers[toolName];
+        if (!handler) throw new Error(`Unknown tool: ${toolName}`);
+        return handler(args);
+      },
+    });
   }
 
   private triageBugs(errorLogs: string[], context: Record<string, unknown>): TriageResult {

package/src/mcps/knowledge-skills/code-analyzer.server.ts

@@ -12,6 +12,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";
 
@@ -310,6 +311,14 @@ class CodeAnalyzerServer extends XrayKnowledgeSkillBase {
       "find_duplicates": async (args) => this.handleFindDuplicates(args),
     };
     this.setupToolHandlers();
+    pluginRegistry.registerToolPlugin({
+      name: "code-analyzer",
+      callTool: async (toolName, args) => {
+        const handler = this.handlers[toolName];
+        if (!handler) throw new Error(`Unknown tool: ${toolName}`);
+        return handler(args);
+      },
+    });
   }
 
   private handleAnalyzeCode(args: unknown) {

package/src/mcps/knowledge-skills/code-review.server.ts

@@ -7,6 +7,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";
 
@@ -190,6 +191,14 @@ class XrayCodeReviewServer extends XrayKnowledgeSkillBase {
       "analyze_proposal": async (args) => this.analyzeProposal(args as AnalyzeProposalArgs),
     };
     this.setupToolHandlers();
+    pluginRegistry.registerToolPlugin({
+      name: "code-review",
+      callTool: async (toolName, args) => {
+        const handler = this.handlers[toolName];
+        if (!handler) throw new Error(`Unknown tool: ${toolName}`);
+        return handler(args);
+      },
+    });
   }
 
   private async analyzeCodeQuality(args: AnalyzeCodeQualityArgs) {

package/src/mcps/knowledge-skills/content-creator.server.ts

@@ -9,6 +9,7 @@ import * as path from "path";
 import { fileURLToPath } from "url";
 import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import { pluginRegistry } from "../../nucleus/plugin-registry.js";
 
 class SEOCopywriterServer extends XrayKnowledgeSkillBase {
   constructor() {
@@ -251,6 +252,14 @@ class SEOCopywriterServer extends XrayKnowledgeSkillBase {
       },
     };
     this.setupToolHandlers();
+    pluginRegistry.registerToolPlugin({
+      name: "content-creator",
+      callTool: async (toolName, args) => {
+        const handler = this.handlers[toolName];
+        if (!handler) throw new Error(`Unknown tool: ${toolName}`);
+        return handler(args);
+      },
+    });
   }
 }