0xray 4.0.13 → 4.0.14

package/dist/mcps/governance.server.js

@@ -0,0 +1,499 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,17 @@
+/**
+ * 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

@@ -0,0 +1,65 @@
+/**
+ * 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);
+}