0xray 4.0.11 → 4.0.13

package/dist/mcps/governance.server.js

@@ -1,499 +0,0 @@
-/**
- * 0xRay Governance MCP Server
- *
- * First-class Governance Service that orchestrates the real individual
- * skill MCP servers (code-review, security-audit, researcher) plus the
- * required Dynamo Solar SSOT filter.
- *
- * This is the primary governance entry point for all integrations
- * (Hermes, OpenCode, OpenClaw, Grok CLI, Jelly, CI/CD).
- *
- * It always runs proposals through the three real skill servers
- * and the Dynamo Solar SSOT filter (required by default).
- */
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
-import { CallToolRequestSchema, isInitializeRequest, } from "@modelcontextprotocol/sdk/types.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { featuresConfigLoader } from "../core/features-config.js";
-import * as fs from "fs";
-import { fileURLToPath } from "url";
-import { randomUUID } from "crypto";
-import { getGovernanceService } from "../governance/governance-service.js";
-import { getCodexPolicyService } from "../governance/codex-policy.service.js";
-import { initializeGovernanceIntegration } from "../integrations/governance/index.js";
-class GovernanceServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("governance", "3.1.0");
-        this.tools = [
-            {
-                name: "govern_proposals",
-                description: "Run one or more proposals through the full 0xRay governance system. " +
-                    "Internal deliberation via 3 skill MCPs + required Dynamo Solar SSOT filter. " +
-                    "Returns merged structured decisions. " +
-                    "Supports regulatory compliance proposals: AML/KYC, PSD2, GDPR content moderation, " +
-                    "and other compliance-related governance scenarios.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        proposals: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    id: { type: "string" },
-                                    type: {
-                                        type: "string",
-                                        enum: ["fix", "refactor", "guard", "automate", "codify", "strategic", "compliance"],
-                                    },
-                                    title: { type: "string" },
-                                    description: { type: "string" },
-                                    evidence: { type: "array", items: { type: "string" } },
-                                    source: { type: "string" },
-                                    confidence: { type: "number" },
-                                },
-                                required: ["type", "title", "description"],
-                            },
-                            description: "List of proposals to govern",
-                        },
-                        context: {
-                            type: "object",
-                            description: "Optional context about the proposals (project, phase, etc.)",
-                        },
-                        options: {
-                            type: "object",
-                            properties: {
-                                require_external: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Whether external Dynamo/Solar governance is required (default: true)",
-                                },
-                            },
-                        },
-                    },
-                    required: ["proposals"],
-                },
-            },
-            {
-                name: "govern_reflection",
-                description: "Parse a reflection (or reflection file) and run its extracted proposals through the full governance system. " +
-                    "This is the primary way to govern outcomes from reflection-based workflows.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        reflectionPath: {
-                            type: "string",
-                            description: "Path to a reflection .md file (alternative to reflectionContent)",
-                        },
-                        reflectionContent: {
-                            type: "string",
-                            description: "Raw reflection content (alternative to reflectionPath)",
-                        },
-                        context: { type: "object" },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: "get_active_codex",
-                description: "Get the currently active Codex (SSOT) — returns metadata about the loaded codex terms, " +
-                    "including version, term count, source path, and governance status. " +
-                    "Optionally include the full raw codex data with includeRaw=true.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        includeRaw: {
-                            type: "boolean",
-                            description: "Whether to include the full raw codex data in the response",
-                            default: false,
-                        },
-                    },
-                    required: [],
-                },
-            },
-        ];
-        this.handlers = {
-            "govern_proposals": async (args) => this.handleGovernProposals(this.validateGovernProposalsArgs(args)),
-            "govern_reflection": async (args) => this.handleGovernReflection(this.validateGovernReflectionArgs(args)),
-            "get_active_codex": async (args) => this.handleGetActiveCodex(args),
-        };
-        this.setupToolHandlers();
-    }
-    validateGovernProposalsArgs(value) {
-        if (!value || typeof value !== 'object') {
-            throw new Error('govern_proposals requires an object argument');
-        }
-        const obj = value;
-        if (!Array.isArray(obj.proposals)) {
-            throw new Error('govern_proposals requires a "proposals" array');
-        }
-        for (let i = 0; i < obj.proposals.length; i++) {
-            const p = obj.proposals[i];
-            if (!p || typeof p !== 'object') {
-                throw new Error(`proposals[${i}] must be an object`);
-            }
-            if (typeof p.type !== 'string' || !['fix', 'refactor', 'guard', 'automate', 'codify', 'strategic', 'compliance'].includes(p.type)) {
-                throw new Error(`proposals[${i}].type must be one of: fix, refactor, guard, automate, codify, strategic, compliance`);
-            }
-            if (typeof p.title !== 'string') {
-                throw new Error(`proposals[${i}].title must be a string`);
-            }
-            if (typeof p.description !== 'string') {
-                throw new Error(`proposals[${i}].description must be a string`);
-            }
-        }
-        return value;
-    }
-    validateGovernReflectionArgs(value) {
-        if (!value || typeof value !== 'object') {
-            throw new Error('govern_reflection requires an object argument');
-        }
-        return value;
-    }
-    setupToolHandlers() {
-        this.setupListToolsHandler();
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "govern_proposals":
-                        return await this.handleGovernProposals(this.validateGovernProposalsArgs(args));
-                    case "govern_reflection":
-                        return await this.handleGovernReflection(this.validateGovernReflectionArgs(args));
-                    case "get_active_codex":
-                        return await this.handleGetActiveCodex(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                frameworkLogger.log("governance-mcp", "tool-error", "error", {
-                    tool: name,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Governance failed: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        });
-    }
-    /** Align tool default with features.json inference_governance.enabled (P0.2). */
-    resolveRequireExternal(explicit) {
-        if (explicit !== undefined)
-            return explicit;
-        try {
-            const config = featuresConfigLoader.loadConfig();
-            return config?.inference_governance?.enabled === true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async handleGovernProposals(args) {
-        const service = getGovernanceService();
-        const request = {
-            proposals: args.proposals.map((p, i) => ({
-                id: p.id || `prop-${Date.now()}-${i}`,
-                type: p.type,
-                title: p.title,
-                description: p.description,
-                evidence: p.evidence || [],
-                source: "manual",
-                confidence: p.confidence || 0.8,
-            })),
-            context: args.context || {},
-            options: {
-                requireExternalDynamo: this.resolveRequireExternal(args.options?.require_external),
-            },
-        };
-        frameworkLogger.log("governance-mcp", "delegating-to-governance-service", "info", {
-            proposalCount: request.proposals.length,
-        });
-        const response = await service.govern(request);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
-        };
-    }
-    async handleGovernReflection(args) {
-        const { reflectionPath, reflectionContent, context } = args;
-        let content = reflectionContent;
-        if (!content && reflectionPath) {
-            if (!fs.existsSync(reflectionPath)) {
-                throw new Error(`Reflection file not found: ${reflectionPath}`);
-            }
-            content = fs.readFileSync(reflectionPath, "utf-8");
-        }
-        if (!content) {
-            throw new Error("Either reflectionPath or reflectionContent must be provided");
-        }
-        frameworkLogger.log("governance-mcp", "parsing-reflection", "info", { reflectionPath, contentLength: content.length });
-        const proposals = this.parseCodexTermsFromReflection(content);
-        if (proposals.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            message: "No codex term proposals found in reflection.",
-                            proposals: [],
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        frameworkLogger.log("governance-mcp", "reflection-proposals-found", "info", { count: proposals.length });
-        // Delegate to the main govern_proposals logic
-        return this.handleGovernProposals({
-            proposals,
-            context: { ...(context || {}), source: "reflection" },
-            options: { require_external: true },
-        });
-    }
-    async handleGetActiveCodex(args) {
-        const includeRaw = args?.includeRaw === true;
-        const snapshot = await getCodexPolicyService().getCurrentCodex(includeRaw);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(snapshot, null, 2),
-                },
-            ],
-        };
-    }
-    parseCodexTermsFromReflection(content) {
-        const CODEX_TERM_SECTION = "## Codex Term Proposals";
-        const PRIORITY_SECTION = "## Implementation Priority Matrix";
-        const startIdx = content.indexOf(CODEX_TERM_SECTION);
-        if (startIdx === -1)
-            return [];
-        const endIdx = content.indexOf(PRIORITY_SECTION);
-        const section = endIdx !== -1
-            ? content.slice(startIdx + CODEX_TERM_SECTION.length, endIdx)
-            : content.slice(startIdx + CODEX_TERM_SECTION.length);
-        const terms = [];
-        const blocks = section.split(/\n### /).filter(b => b.trim().length > 0);
-        for (const block of blocks) {
-            const nameMatch = block.match(/^([^\n]+)/);
-            if (!nameMatch || !nameMatch[1])
-                continue;
-            const name = nameMatch[1].trim();
-            const catMatch = block.match(/\*\*Category\*\*:\s*(.+)/);
-            const sevMatch = block.match(/\*\*Severity\*\*:\s*(.+)/);
-            const ruleMatch = block.match(/\*\*Detection Rule\*\*:\s*"(.+)"/);
-            const targetMatch = block.match(/\*\*Implementation Target\*\*:\s*(.+)/);
-            const severity = (sevMatch?.[1]?.trim() ?? "medium").toLowerCase();
-            const category = (catMatch?.[1]?.trim() ?? "design").toLowerCase();
-            let type = "codify";
-            if (category.includes("anti-pattern"))
-                type = "guard";
-            else if (category.includes("aspirational"))
-                type = "codify";
-            else if (category.includes("process"))
-                type = "automate";
-            else if (category.includes("design"))
-                type = "refactor";
-            terms.push({
-                id: `reflection-${Date.now()}-${terms.length}`,
-                type,
-                title: name,
-                description: ruleMatch?.[1] ?? `Implement ${name}`,
-                evidence: [
-                    `Severity: ${severity}`,
-                    `Target: ${targetMatch?.[1]?.trim() ?? "TBD"}`,
-                ],
-                source: "reflection",
-                confidence: severity === "blocking" ? 0.95 : severity === "high" ? 0.85 : severity === "medium" ? 0.7 : 0.5,
-            });
-        }
-        return terms;
-    }
-    async initializeGovernance() {
-        try {
-            const config = featuresConfigLoader.loadConfig();
-            const govConfig = config?.inference_governance;
-            if (govConfig?.enabled) {
-                await initializeGovernanceIntegration();
-                frameworkLogger.log("governance-server", "dynamo-solar-ssot-initialized", "info", {
-                    endpoint: govConfig.endpoint_url || "default",
-                });
-            }
-            else {
-                frameworkLogger.log("governance-server", "dynamo-solar-ssot-disabled", "info", {
-                    message: "Dynamo Solar SSOT disabled in features config, external governance will abstain",
-                });
-            }
-        }
-        catch (err) {
-            frameworkLogger.log("governance-server", "dynamo-solar-ssot-init-error", "error", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    async run() {
-        await this.initializeGovernance();
-        await super.run();
-    }
-    async connect(transport) {
-        await this.server.connect(transport);
-    }
-    /**
-     * Run as HTTP server using Streamable HTTP transport (for Grok CLI compatibility).
-     * Uses per-session transports so concurrent clients can each initialize independently.
-     */
-    async runHttp(port = parseInt(process.env.MCP_PORT ?? "3100", 10)) {
-        await this.initializeGovernance();
-        const mcpHost = process.env.MCP_HOST || "127.0.0.1";
-        const allowedHosts = process.env.MCP_ALLOWED_HOSTS?.split(",");
-        const app = createMcpExpressApp({
-            host: mcpHost,
-            ...(allowedHosts ? { allowedHosts } : {}),
-        });
-        const transports = {};
-        const apiKey = process.env.GOVERNANCE_API_KEY;
-        if (apiKey) {
-            frameworkLogger.log("governance-mcp", "api-key-auth-enabled", "info", {});
-        }
-        else {
-            frameworkLogger.log("governance-mcp", "api-key-auth-disabled", "warning", {
-                message: "GOVERNANCE_API_KEY not set - HTTP server has no authentication",
-            });
-        }
-        app.use((req, res, next) => {
-            if (apiKey && req.path !== "/health") {
-                const providedKey = req.headers["x-api-key"];
-                if (!providedKey || providedKey !== apiKey) {
-                    res.status(401).json({ error: "Unauthorized" });
-                    return;
-                }
-            }
-            next();
-        });
-        const mcpPostHandler = async (req, res) => {
-            try {
-                const sessionId = req.headers["mcp-session-id"];
-                let transport;
-                if (sessionId && transports[sessionId]) {
-                    transport = transports[sessionId];
-                }
-                else if (!sessionId && isInitializeRequest(req.body)) {
-                    transport = new StreamableHTTPServerTransport({
-                        sessionIdGenerator: () => randomUUID(),
-                        onsessioninitialized: (sid) => {
-                            if (transport) {
-                                transports[sid] = transport;
-                                frameworkLogger.log("governance-mcp", "session-initialized", "info", {
-                                    sessionId: sid,
-                                });
-                            }
-                        },
-                    });
-                    transport.onclose = () => {
-                        const sid = transport?.sessionId;
-                        if (sid && transports[sid]) {
-                            delete transports[sid];
-                            frameworkLogger.log("governance-mcp", "session-closed", "info", { sessionId: sid });
-                        }
-                    };
-                    const sessionServer = new GovernanceServer();
-                    await sessionServer.connect(transport);
-                    await transport.handleRequest(req, res, req.body);
-                    return;
-                }
-                else {
-                    res.status(400).json({
-                        jsonrpc: "2.0",
-                        error: { code: -32000, message: "Bad Request: No valid session ID provided" },
-                        id: null,
-                    });
-                    return;
-                }
-                await transport.handleRequest(req, res, req.body);
-            }
-            catch (error) {
-                frameworkLogger.log("governance-mcp", "http-handler-error", "error", { error: String(error) });
-                if (!res.headersSent) {
-                    res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal error" }, id: null });
-                }
-            }
-        };
-        app.post("/mcp", mcpPostHandler);
-        app.get("/mcp", async (req, res) => {
-            const sessionId = req.headers["mcp-session-id"];
-            if (!sessionId || !transports[sessionId]) {
-                res.status(400).send("Invalid or missing session ID");
-                return;
-            }
-            try {
-                await transports[sessionId].handleRequest(req, res);
-            }
-            catch (error) {
-                frameworkLogger.log("governance-mcp", "http-sse-error", "error", { error: String(error) });
-                if (!res.headersSent) {
-                    res.status(500).send("Error processing SSE stream");
-                }
-            }
-        });
-        app.delete("/mcp", async (req, res) => {
-            const sessionId = req.headers["mcp-session-id"];
-            if (!sessionId || !transports[sessionId]) {
-                res.status(400).send("Invalid or missing session ID");
-                return;
-            }
-            try {
-                await transports[sessionId].handleRequest(req, res);
-            }
-            catch (error) {
-                frameworkLogger.log("governance-mcp", "http-delete-error", "error", { error: String(error) });
-                if (!res.headersSent) {
-                    res.status(500).send("Error processing session termination");
-                }
-            }
-        });
-        app.get("/health", (_req, res) => {
-            res.json({ status: "ok", server: "governance" });
-        });
-        const closeAllTransports = async () => {
-            await Promise.all(Object.values(transports).map((t) => t.close()));
-        };
-        app.listen(port, () => {
-            frameworkLogger.log("governance-mcp", "http-listening", "info", { port });
-        });
-        process.on("SIGINT", () => { void closeAllTransports().then(() => process.exit(0)); });
-        process.on("SIGTERM", () => { void closeAllTransports().then(() => process.exit(0)); });
-    }
-}
-// Start the server if this file is run directly
-const entryPoint = fs.realpathSync(process.argv[1] ?? "");
-if (entryPoint && fileURLToPath(import.meta.url) === entryPoint) {
-    // If --port or MCP_PORT is set, use HTTP transport (for Grok CLI compatibility)
-    const cliPort = process.argv.find((a) => a.startsWith("--port="))?.split("=")[1];
-    const port = parseInt(cliPort ?? process.env.MCP_PORT ?? "", 10);
-    if (!isNaN(port)) {
-        const server = new GovernanceServer();
-        server.runHttp(port).catch((error) => {
-            frameworkLogger.log('governance-mcp', 'http-startup-error', 'error', { error: String(error) });
-            process.exit(1);
-        });
-    }
-    else {
-        const server = new GovernanceServer();
-        server.run().catch((error) => {
-            frameworkLogger.log('governance-mcp', 'fatal-startup-error', 'error', { error: String(error) });
-            process.exit(1);
-        });
-    }
-}
-export { GovernanceServer };

package/dist/mcps/in-process-skill-registry.d.ts

@@ -1,20 +0,0 @@
-interface AnalyzeProposalArgs {
-    proposalTitle?: string;
-    proposalDescription?: string;
-    evidence?: string[];
-    proposalType?: string;
-}
-export interface MCPToolResult {
-    content?: Array<{
-        type: string;
-        text: string;
-    }>;
-}
-interface AnalyzeProposalResult {
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}
-export declare function callInProcessSkill(serverName: string, toolName: string, args: Record<string, unknown>): Promise<AnalyzeProposalResult>;
-export type { AnalyzeProposalArgs, AnalyzeProposalResult };

package/dist/mcps/in-process-skill-registry.js

@@ -1,48 +0,0 @@
-import { XrayCodeReviewServer } from "./knowledge-skills/code-review.server.js";
-import { XraySecurityAuditServer } from "./knowledge-skills/security-audit.server.js";
-import { XrayLibrarianServer } from "./researcher.server.js";
-const instances = new Map();
-function getCodeReview() {
-    if (!instances.has("code-review")) {
-        const server = new XrayCodeReviewServer();
-        instances.set("code-review", {
-            analyzeProposal: (args) => server.analyzeProposal(args),
-        });
-    }
-    return instances.get("code-review");
-}
-function getSecurityAudit() {
-    if (!instances.has("security-audit")) {
-        const server = new XraySecurityAuditServer();
-        instances.set("security-audit", {
-            analyzeProposal: (args) => server.analyzeProposal(args),
-        });
-    }
-    return instances.get("security-audit");
-}
-function getResearcher() {
-    if (!instances.has("researcher")) {
-        const server = new XrayLibrarianServer();
-        instances.set("researcher", {
-            analyzeProposal: (args) => server.analyzeProposal(args),
-        });
-    }
-    return instances.get("researcher");
-}
-const registry = {
-    "code-review": getCodeReview,
-    "security-audit": getSecurityAudit,
-    "researcher": getResearcher,
-};
-export async function callInProcessSkill(serverName, toolName, args) {
-    const factory = registry[serverName];
-    if (!factory) {
-        throw new Error(`No in-process handler registered for server: ${serverName}`);
-    }
-    if (toolName !== "analyze_proposal") {
-        const supported = Object.keys(registry).join(", ");
-        throw new Error(`In-process skill registry only supports "analyze_proposal" for servers: ${supported}. Got "${toolName}"`);
-    }
-    const handler = factory();
-    return handler.analyzeProposal(args);
-}

package/dist/mcps/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * xray MCP Server Manifest
- *
- * Canonical registry of all MCP servers. Add new servers here.
- * Each entry documents the server name, source file, and server type.
- */
-export interface McpServerEntry {
-    serverName: string;
-    sourceFile: string;
-    type: "top-level" | "knowledge-skill" | "orchestrator";
-    registered: boolean;
-    description: string;
-}
-export declare const MCP_SERVERS: McpServerEntry[];
-export declare function getMcpServer(serverName: string): McpServerEntry | undefined;
-export declare function getRegisteredServers(): McpServerEntry[];
-export declare function getUnregisteredServers(): McpServerEntry[];

package/dist/mcps/index.js

@@ -1,65 +0,0 @@
-/**
- * xray MCP Server Manifest
- *
- * Canonical registry of all MCP servers. Add new servers here.
- * Each entry documents the server name, source file, and server type.
- */
-export const MCP_SERVERS = [
-    // ── Top-level servers ──
-    { serverName: "architect-tools", sourceFile: "mcps/architect-tools.server.ts", type: "top-level", registered: true, description: "Architect design tools" },
-    { serverName: "auto-format", sourceFile: "mcps/auto-format.server.ts", type: "top-level", registered: true, description: "Auto-format code" },
-    { serverName: "boot-orchestrator", sourceFile: "mcps/boot-orchestrator.server.ts", type: "top-level", registered: true, description: "Boot sequence orchestration" },
-    { serverName: "enforcer", sourceFile: "mcps/enforcer-tools.server.ts", type: "top-level", registered: true, description: "Codex compliance enforcement" },
-    { serverName: "estimation-validator", sourceFile: "mcps/estimation.server.ts", type: "top-level", registered: true, description: "Task estimation validation" },
-    { serverName: "framework-compliance-audit", sourceFile: "mcps/framework-compliance-audit.server.ts", type: "top-level", registered: true, description: "Framework compliance audits" },
-    { serverName: "framework-help", sourceFile: "mcps/framework-help.server.ts", type: "top-level", registered: true, description: "Framework help and guidance" },
-    { serverName: "governance", sourceFile: "mcps/governance.server.ts", type: "top-level", registered: true, description: "Governance deliberation pipeline" },
-    { serverName: "lint", sourceFile: "mcps/lint.server.ts", type: "top-level", registered: true, description: "Code linting" },
-    { serverName: "model-health-check", sourceFile: "mcps/model-health-check.server.ts", type: "top-level", registered: true, description: "Model health monitoring" },
-    { serverName: "performance-analysis", sourceFile: "mcps/performance-analysis.server.ts", type: "top-level", registered: true, description: "Performance analysis" },
-    { serverName: "processor-pipeline", sourceFile: "mcps/processor-pipeline.server.ts", type: "top-level", registered: true, description: "Processor pipeline" },
-    { serverName: "researcher", sourceFile: "mcps/researcher.server.ts", type: "top-level", registered: true, description: "Codebase exploration" },
-    { serverName: "security-scan", sourceFile: "mcps/security-scan.server.ts", type: "top-level", registered: true, description: "Security vulnerability scanning" },
-    { serverName: "state-manager", sourceFile: "mcps/state-manager.server.ts", type: "top-level", registered: true, description: "State management" },
-    // ── Knowledge skill servers ──
-    { serverName: "api-design", sourceFile: "mcps/knowledge-skills/api-design.server.ts", type: "knowledge-skill", registered: false, description: "API design expertise" },
-    { serverName: "architecture-patterns", sourceFile: "mcps/knowledge-skills/architecture-patterns.server.ts", type: "knowledge-skill", registered: false, description: "Architecture pattern guidance" },
-    { serverName: "bug-triage-specialist", sourceFile: "mcps/knowledge-skills/bug-triage-specialist.server.ts", type: "knowledge-skill", registered: true, description: "Bug triage and investigation" },
-    { serverName: "code-analyzer", sourceFile: "mcps/knowledge-skills/code-analyzer.server.ts", type: "knowledge-skill", registered: true, description: "Static code analysis" },
-    { serverName: "code-review", sourceFile: "mcps/knowledge-skills/code-review.server.ts", type: "knowledge-skill", registered: true, description: "Code review and quality assessment" },
-    { serverName: "content-creator", sourceFile: "mcps/knowledge-skills/content-creator.server.ts", type: "knowledge-skill", registered: false, description: "Content creation" },
-    { serverName: "database-design", sourceFile: "mcps/knowledge-skills/database-design.server.ts", type: "knowledge-skill", registered: false, description: "Database design expertise" },
-    { serverName: "devops-deployment", sourceFile: "mcps/knowledge-skills/devops-deployment.server.ts", type: "knowledge-skill", registered: false, description: "DevOps and deployment" },
-    { serverName: "git-workflow", sourceFile: "mcps/knowledge-skills/git-workflow.server.ts", type: "knowledge-skill", registered: false, description: "Git workflow guidance" },
-    { serverName: "growth-strategist", sourceFile: "mcps/knowledge-skills/growth-strategist.server.ts", type: "knowledge-skill", registered: false, description: "Growth strategy" },
-    { serverName: "log-monitor", sourceFile: "mcps/knowledge-skills/log-monitor.server.ts", type: "knowledge-skill", registered: true, description: "Log monitoring" },
-    { serverName: "mobile-development", sourceFile: "mcps/knowledge-skills/mobile-development.server.ts", type: "knowledge-skill", registered: false, description: "Mobile development" },
-    { serverName: "multimodal-looker", sourceFile: "mcps/knowledge-skills/multimodal-looker.server.ts", type: "knowledge-skill", registered: false, description: "Multimodal file analysis" },
-    { serverName: "performance-optimization", sourceFile: "mcps/knowledge-skills/performance-optimization.server.ts", type: "knowledge-skill", registered: true, description: "Performance optimization" },
-    { serverName: "project-analysis", sourceFile: "mcps/knowledge-skills/project-analysis.server.ts", type: "knowledge-skill", registered: false, description: "Project analysis" },
-    { serverName: "refactoring-strategies", sourceFile: "mcps/knowledge-skills/refactoring-strategies.server.ts", type: "knowledge-skill", registered: true, description: "Refactoring strategies" },
-    { serverName: "security-audit", sourceFile: "mcps/knowledge-skills/security-audit.server.ts", type: "knowledge-skill", registered: true, description: "Security auditing" },
-    { serverName: "seo-consultant", sourceFile: "mcps/knowledge-skills/seo-consultant.server.ts", type: "knowledge-skill", registered: false, description: "SEO consulting" },
-    { serverName: "storyteller", sourceFile: "mcps/knowledge-skills/storyteller.server.ts", type: "knowledge-skill", registered: false, description: "Reflections, sagas, and technical narratives" },
-    { serverName: "session-management", sourceFile: "mcps/knowledge-skills/session-management.server.ts", type: "knowledge-skill", registered: true, description: "Session management" },
-    { serverName: "skill-invocation", sourceFile: "mcps/knowledge-skills/skill-invocation.server.ts", type: "knowledge-skill", registered: true, description: "Skill invocation" },
-    { serverName: "strategist", sourceFile: "mcps/knowledge-skills/strategist.server.ts", type: "knowledge-skill", registered: false, description: "Strategic planning" },
-    { serverName: "tech-writer", sourceFile: "mcps/knowledge-skills/tech-writer.server.ts", type: "knowledge-skill", registered: false, description: "Technical writing" },
-    { serverName: "testing-strategy", sourceFile: "mcps/knowledge-skills/testing-strategy.server.ts", type: "knowledge-skill", registered: true, description: "Testing strategy" },
-    { serverName: "ui-ux-design", sourceFile: "mcps/knowledge-skills/ui-ux-design.server.ts", type: "knowledge-skill", registered: false, description: "UI/UX design" },
-    // ── Orchestrator server ──
-    { serverName: "orchestrator", sourceFile: "mcps/orchestrator/server.ts", type: "orchestrator", registered: true, description: "thinDispatch 7-flow orchestration" },
-    // ── Aliases (point to same source as primary) ──
-    { serverName: "code-reviewer", sourceFile: "mcps/knowledge-skills/code-review.server.ts", type: "knowledge-skill", registered: true, description: "Alias for code-review" },
-    { serverName: "security-auditor", sourceFile: "mcps/knowledge-skills/security-audit.server.ts", type: "knowledge-skill", registered: true, description: "Alias for security-audit" },
-    { serverName: "testing-lead", sourceFile: "mcps/knowledge-skills/testing-strategy.server.ts", type: "knowledge-skill", registered: true, description: "Alias for testing-strategy" },
-];
-export function getMcpServer(serverName) {
-    return MCP_SERVERS.find(s => s.serverName === serverName);
-}
-export function getRegisteredServers() {
-    return MCP_SERVERS.filter(s => s.registered);
-}
-export function getUnregisteredServers() {
-    return MCP_SERVERS.filter(s => !s.registered);
-}