@rigour-labs/mcp 2.9.4 → 2.11.0

package/README.md

@@ -0,0 +1,72 @@
+# 🛡️ Rigour MCP Server
+
+**The Quality Gate for AI-Assisted Engineering.**
+
+Rigour is a local-first Model Context Protocol (MCP) server that forces AI agents (Claude, Cursor, Windsurf, etc.) to meet strict engineering standards before marking tasks as complete.
+
+[![Registry](https://img.shields.io/badge/MCP-Registry-brightgreen)](https://github.com/mcp)
+[![npm version](https://img.shields.io/npm/v/@rigour-labs/mcp?color=cyan)](https://www.npmjs.com/package/@rigour-labs/mcp)
+
+---
+
+## 🚀 Overview
+
+Rigour moves code quality enforcement from the "Post-Commit" phase to the "In-Progress" phase. By running as an MCP server inside your editor, it provides the AI with a deterministic PASS/FAIL loop, preventing "Vibe Coding" and broken builds.
+
+### Key Features:
+- **Quality Gates**: Deterministic checks for file size, complexity, and hygiene.
+- **Context Memory**: Persistent memory that tracks project rules and patterns across sessions.
+- **Pattern Reinvention Blocking**: Warns or blocks the AI when it tries to rewrite existing utilities.
+- **Security Audits**: Real-time CVE detection for dependencies the AI is suggesting.
+- **Zero Cloud**: 100% local analysis. Your code never leaves your machine.
+
+---
+
+## 🛠️ Available Tools
+
+| Tool | Description |
+|:---|:---|
+| `rigour_check` | Runs all configured quality gates on the current workspace. |
+| `rigour_explain` | Explains why a specific gate failed and provides actionable fix instructions. |
+| `rigour_check_pattern` | Checks if a proposed code pattern already exists in the codebase. |
+| `rigour_remember` | Stores project-specific context or rules in Rigour's persistent memory. |
+| `rigour_recall` | Retrieves stored context to guide AI generation. |
+
+---
+
+## 📦 Installation
+
+### 1. Install via npm
+```bash
+npm install -g @rigour-labs/mcp
+```
+
+### 2. Configure your IDE
+
+#### Cursor / Claude Desktop
+Add the following to your MCP settings:
+```json
+{
+  "mcpServers": {
+    "rigour": {
+      "command": "npx",
+      "args": ["-y", "@rigour-labs/mcp"],
+      "env": {
+        "RIGOUR_CWD": "/path/to/your/project"
+      }
+    }
+  }
+}
+```
+
+---
+
+## 📖 Documentation
+
+For full configuration and advanced usage, visit **[docs.rigour.run](https://docs.rigour.run)**.
+
+---
+
+## 📜 License
+
+MIT © [Rigour Labs](https://github.com/rigour-labs)

package/dist/index.js

@@ -1,17 +1,14 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const yaml_1 = __importDefault(require("yaml"));
-const core_1 = require("@rigour-labs/core");
-const server = new index_js_1.Server({
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs-extra";
+import path from "path";
+import yaml from "yaml";
+import { randomUUID } from "crypto";
+import { GateRunner, ConfigSchema, } from "@rigour-labs/core";
+import { PatternMatcher, loadPatternIndex, getDefaultIndexPath, StalenessDetector, SecurityDetector } from "@rigour-labs/core/pattern-index";
+const server = new Server({
     name: "rigour-mcp",
     version: "1.0.0",
 }, {
@@ -20,31 +17,48 @@ const server = new index_js_1.Server({
     },
 });
 async function loadConfig(cwd) {
-    const configPath = path_1.default.join(cwd, "rigour.yml");
-    if (!(await fs_extra_1.default.pathExists(configPath))) {
+    const configPath = path.join(cwd, "rigour.yml");
+    if (!(await fs.pathExists(configPath))) {
         throw new Error("Rigour configuration (rigour.yml) not found. The agent must run `rigour init` first to establish engineering standards.");
     }
-    const configContent = await fs_extra_1.default.readFile(configPath, "utf-8");
-    return core_1.ConfigSchema.parse(yaml_1.default.parse(configContent));
+    const configContent = await fs.readFile(configPath, "utf-8");
+    return ConfigSchema.parse(yaml.parse(configContent));
 }
 async function getMemoryPath(cwd) {
-    const rigourDir = path_1.default.join(cwd, ".rigour");
-    await fs_extra_1.default.ensureDir(rigourDir);
-    return path_1.default.join(rigourDir, "memory.json");
+    const rigourDir = path.join(cwd, ".rigour");
+    await fs.ensureDir(rigourDir);
+    return path.join(rigourDir, "memory.json");
 }
 async function loadMemory(cwd) {
     const memPath = await getMemoryPath(cwd);
-    if (await fs_extra_1.default.pathExists(memPath)) {
-        const content = await fs_extra_1.default.readFile(memPath, "utf-8");
+    if (await fs.pathExists(memPath)) {
+        const content = await fs.readFile(memPath, "utf-8");
         return JSON.parse(content);
     }
     return { memories: {} };
 }
 async function saveMemory(cwd, store) {
     const memPath = await getMemoryPath(cwd);
-    await fs_extra_1.default.writeFile(memPath, JSON.stringify(store, null, 2));
+    await fs.writeFile(memPath, JSON.stringify(store, null, 2));
 }
-server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+// Helper to log events for Rigour Studio
+async function logStudioEvent(cwd, event) {
+    try {
+        const rigourDir = path.join(cwd, ".rigour");
+        await fs.ensureDir(rigourDir);
+        const eventsPath = path.join(rigourDir, "events.jsonl");
+        const logEntry = JSON.stringify({
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            ...event
+        }) + "\n";
+        await fs.appendFile(eventsPath, logEntry);
+    }
+    catch {
+        // Silent fail - Studio logging is non-blocking and zero-telemetry
+    }
+}
+server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
             {
@@ -189,19 +203,67 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
                     required: ["cwd", "key"],
                 },
             },
+            {
+                name: "rigour_check_pattern",
+                description: "Checks if a proposed code pattern (function, component, etc.) already exists, is stale, or has security vulnerabilities (CVEs). CALL THIS BEFORE CREATING NEW CODE.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        name: {
+                            type: "string",
+                            description: "The name of the function, class, or component you want to create.",
+                        },
+                        type: {
+                            type: "string",
+                            description: "The type of pattern (e.g., 'function', 'component', 'hook', 'type').",
+                        },
+                        intent: {
+                            type: "string",
+                            description: "What the code is for (e.g., 'format dates', 'user authentication').",
+                        },
+                    },
+                    required: ["cwd", "name"],
+                },
+            },
+            {
+                name: "rigour_security_audit",
+                description: "Runs a live security audit (CVE check) on the project dependencies.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                    },
+                    required: ["cwd"],
+                },
+            },
         ],
     };
 });
-server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const cwd = args?.cwd || process.cwd();
+    const requestId = randomUUID();
     try {
+        await logStudioEvent(cwd, {
+            type: "tool_call",
+            requestId,
+            tool: name,
+            arguments: args
+        });
         const config = await loadConfig(cwd);
-        const runner = new core_1.GateRunner(config);
+        const runner = new GateRunner(config);
+        let result;
         switch (name) {
             case "rigour_check": {
                 const report = await runner.run(cwd);
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -209,11 +271,14 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                // Add the report to the tool_response log for high-fidelity Studio visualization
+                result._rigour_report = report;
+                break;
             }
             case "rigour_explain": {
                 const report = await runner.run(cwd);
                 if (report.status === "PASS") {
-                    return {
+                    result = {
                         content: [
                             {
                                 type: "text",
@@ -222,21 +287,24 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         ],
                     };
                 }
-                const bullets = report.failures.map((f, i) => {
-                    return `${i + 1}. [${f.id.toUpperCase()}] ${f.title}: ${f.details}${f.hint ? ` (Hint: ${f.hint})` : ''}`;
-                }).join("\n");
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `RIGOUR EXPLAIN:\n\n${bullets}`,
-                        },
-                    ],
-                };
+                else {
+                    const bullets = report.failures.map((f, i) => {
+                        return `${i + 1}. [${f.id.toUpperCase()}] ${f.title}: ${f.details}${f.hint ? ` (Hint: ${f.hint})` : ''}`;
+                    }).join("\n");
+                    result = {
+                        content: [
+                            {
+                                type: "text",
+                                text: `RIGOUR EXPLAIN:\n\n${bullets}`,
+                            },
+                        ],
+                    };
+                }
+                break;
             }
             case "rigour_status": {
                 const report = await runner.run(cwd);
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -249,11 +317,12 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             }
             case "rigour_get_fix_packet": {
                 const report = await runner.run(cwd);
                 if (report.status === "PASS") {
-                    return {
+                    result = {
                         content: [
                             {
                                 type: "text",
@@ -262,28 +331,31 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         ],
                     };
                 }
-                const packet = report.failures.map((f, i) => {
-                    let text = `FIX TASK ${i + 1}: [${f.id.toUpperCase()}] ${f.title}\n`;
-                    text += `   - CONTEXT: ${f.details}\n`;
-                    if (f.files && f.files.length > 0) {
-                        text += `   - TARGET FILES: ${f.files.join(", ")}\n`;
-                    }
-                    if (f.hint) {
-                        text += `   - REFACTORING GUIDANCE: ${f.hint}\n`;
-                    }
-                    return text;
-                }).join("\n---\n");
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `ENGINEERING REFINEMENT REQUIRED:\n\nThe project state violated ${report.failures.length} quality gates. You MUST address these failures before declaring the task complete:\n\n${packet}`,
-                        },
-                    ],
-                };
+                else {
+                    const packet = report.failures.map((f, i) => {
+                        let text = `FIX TASK ${i + 1}: [${f.id.toUpperCase()}] ${f.title}\n`;
+                        text += `   - CONTEXT: ${f.details}\n`;
+                        if (f.files && f.files.length > 0) {
+                            text += `   - TARGET FILES: ${f.files.join(", ")}\n`;
+                        }
+                        if (f.hint) {
+                            text += `   - REFACTORING GUIDANCE: ${f.hint}\n`;
+                        }
+                        return text;
+                    }).join("\n---\n");
+                    result = {
+                        content: [
+                            {
+                                type: "text",
+                                text: `ENGINEERING REFINEMENT REQUIRED:\n\nThe project state violated ${report.failures.length} quality gates. You MUST address these failures before declaring the task complete:\n\n${packet}`,
+                            },
+                        ],
+                    };
+                }
+                break;
             }
             case "rigour_list_gates":
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -296,8 +368,9 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             case "rigour_get_config":
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -305,6 +378,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             case "rigour_remember": {
                 const { key, value } = args;
                 const store = await loadMemory(cwd);
@@ -313,7 +387,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     timestamp: new Date().toISOString(),
                 };
                 await saveMemory(cwd, store);
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -321,6 +395,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             }
             case "rigour_recall": {
                 const { key } = args;
@@ -328,7 +403,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 if (key) {
                     const memory = store.memories[key];
                     if (!memory) {
-                        return {
+                        result = {
                             content: [
                                 {
                                     type: "text",
@@ -337,69 +412,169 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             ],
                         };
                     }
-                    return {
+                    else {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})`,
+                                },
+                            ],
+                        };
+                    }
+                }
+                else {
+                    const keys = Object.keys(store.memories);
+                    if (keys.length === 0) {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "NO MEMORIES STORED. Use rigour_remember to persist important instructions.",
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        const allMemories = keys.map(k => {
+                            const mem = store.memories[k];
+                            return `## ${k}\n${mem.value}\n(Stored: ${mem.timestamp})`;
+                        }).join("\n\n---\n\n");
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `RECALLED ALL MEMORIES (${keys.length} items):\n\n${allMemories}\n\n---\nIMPORTANT: Follow these stored instructions throughout this session.`,
+                                },
+                            ],
+                        };
+                    }
+                }
+                break;
+            }
+            case "rigour_forget": {
+                const { key } = args;
+                const store = await loadMemory(cwd);
+                if (!store.memories[key]) {
+                    result = {
                         content: [
                             {
                                 type: "text",
-                                text: `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})`,
+                                text: `NO MEMORY FOUND for key "${key}". Nothing to forget.`,
                             },
                         ],
                     };
                 }
-                const keys = Object.keys(store.memories);
-                if (keys.length === 0) {
-                    return {
+                else {
+                    delete store.memories[key];
+                    await saveMemory(cwd, store);
+                    result = {
                         content: [
                             {
                                 type: "text",
-                                text: "NO MEMORIES STORED. Use rigour_remember to persist important instructions.",
+                                text: `MEMORY DELETED: "${key}" has been removed.`,
                             },
                         ],
                     };
                 }
-                const allMemories = keys.map(k => {
-                    const mem = store.memories[k];
-                    return `## ${k}\n${mem.value}\n(Stored: ${mem.timestamp})`;
-                }).join("\n\n---\n\n");
-                return {
+                break;
+            }
+            case "rigour_check_pattern": {
+                const { name: patternName, type, intent } = args;
+                const indexPath = getDefaultIndexPath(cwd);
+                const index = await loadPatternIndex(indexPath);
+                let resultText = "";
+                // 1. Check for Reinvention
+                if (index) {
+                    const matcher = new PatternMatcher(index);
+                    const matchResult = await matcher.match({ name: patternName, type, intent });
+                    if (matchResult.status === "FOUND_SIMILAR") {
+                        resultText += `🚨 PATTERN REINVENTION DETECTED\n`;
+                        resultText += `Similar pattern already exists: "${matchResult.matches[0].pattern.name}" in ${matchResult.matches[0].pattern.file}\n`;
+                        resultText += `SUGGESTION: ${matchResult.suggestion}\n\n`;
+                    }
+                }
+                else {
+                    resultText += `⚠️ Pattern index not found. Run 'rigour index' to enable reinvention detection.\n\n`;
+                }
+                // 2. Check for Staleness/Best Practices
+                const detector = new StalenessDetector(cwd);
+                const staleness = await detector.checkStaleness(`${type || 'function'} ${patternName} {}`);
+                if (staleness.status !== "FRESH") {
+                    resultText += `⚠️ STALENESS/ANTI-PATTERN WARNING\n`;
+                    for (const issue of staleness.issues) {
+                        resultText += `- ${issue.reason}\n  REPLACEMENT: ${issue.replacement}\n`;
+                    }
+                    resultText += `\n`;
+                }
+                // 3. Check Security for this library (if it's an import)
+                if (intent && intent.includes('import')) {
+                    const security = new SecurityDetector(cwd);
+                    const audit = await security.runAudit();
+                    const relatedVulns = audit.vulnerabilities.filter(v => patternName.toLowerCase().includes(v.packageName.toLowerCase()) ||
+                        intent.toLowerCase().includes(v.packageName.toLowerCase()));
+                    if (relatedVulns.length > 0) {
+                        resultText += `🛡️ SECURITY/CVE WARNING\n`;
+                        for (const v of relatedVulns) {
+                            resultText += `- [${v.severity.toUpperCase()}] ${v.packageName}: ${v.title} (${v.url})\n`;
+                        }
+                        resultText += `\n`;
+                    }
+                }
+                if (!resultText) {
+                    resultText = `✅ Pattern "${patternName}" is fresh, secure, and unique to the codebase.\n\nRECOMMENDED ACTION: Proceed with implementation.`;
+                }
+                else {
+                    let recommendation = "Proceed with caution, addressing the warnings above.";
+                    if (resultText.includes("🚨 PATTERN REINVENTION")) {
+                        recommendation = "STOP and REUSE the existing pattern mentioned above. Do not create a duplicate.";
+                    }
+                    else if (resultText.includes("🛡️ SECURITY/CVE WARNING")) {
+                        recommendation = "STOP and update your dependencies or find an alternative library. Do not proceed with vulnerable code.";
+                    }
+                    else if (resultText.includes("⚠️ STALENESS")) {
+                        recommendation = "Follow the replacement suggestion to ensure best practices.";
+                    }
+                    resultText += `\nRECOMMENDED ACTION: ${recommendation}`;
+                }
+                result = {
                     content: [
                         {
                             type: "text",
-                            text: `RECALLED ALL MEMORIES (${keys.length} items):\n\n${allMemories}\n\n---\nIMPORTANT: Follow these stored instructions throughout this session.`,
+                            text: resultText,
                         },
                     ],
                 };
+                break;
             }
-            case "rigour_forget": {
-                const { key } = args;
-                const store = await loadMemory(cwd);
-                if (!store.memories[key]) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `NO MEMORY FOUND for key "${key}". Nothing to forget.`,
-                            },
-                        ],
-                    };
-                }
-                delete store.memories[key];
-                await saveMemory(cwd, store);
-                return {
+            case "rigour_security_audit": {
+                const security = new SecurityDetector(cwd);
+                const summary = await security.getSecuritySummary();
+                result = {
                     content: [
                         {
                             type: "text",
-                            text: `MEMORY DELETED: "${key}" has been removed.`,
+                            text: summary,
                         },
                     ],
                 };
+                break;
             }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
+        await logStudioEvent(cwd, {
+            type: "tool_response",
+            requestId,
+            tool: name,
+            status: "success",
+            content: result.content,
+            _rigour_report: result._rigour_report
+        });
+        return result;
     }
     catch (error) {
-        return {
+        const errorResponse = {
             content: [
                 {
                     type: "text",
@@ -408,10 +583,19 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             ],
             isError: true,
         };
+        await logStudioEvent(cwd, {
+            type: "tool_response",
+            requestId,
+            tool: name,
+            status: "error",
+            error: error.message,
+            content: errorResponse.content
+        });
+        return errorResponse;
     }
 });
 async function main() {
-    const transport = new stdio_js_1.StdioServerTransport();
+    const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("Rigour MCP server v1.0.0 running on stdio");
 }

package/dist/smoke.test.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-(0, vitest_1.describe)('MCP Smoke Test', () => {
-    (0, vitest_1.it)('should pass', async () => {
-        (0, vitest_1.expect)(true).toBe(true);
+import { describe, it, expect } from 'vitest';
+describe('MCP Smoke Test', () => {
+    it('should pass', async () => {
+        expect(true).toBe(true);
     });
 });

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "2.9.4",
+  "version": "2.11.0",
+  "type": "module",
   "mcpName": "io.github.rigour-labs/rigour",
   "description": "Quality gates for AI-generated code. Forces AI agents to meet strict engineering standards with PASS/FAIL enforcement.",
   "bin": {
@@ -18,7 +19,7 @@
     "@modelcontextprotocol/sdk": "^1.25.2",
     "fs-extra": "^11.2.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.9.4"
+    "@rigour-labs/core": "2.11.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.3"

package/src/index.ts

@@ -8,7 +8,19 @@ import {
 import fs from "fs-extra";
 import path from "path";
 import yaml from "yaml";
-import { GateRunner, ConfigSchema, Report } from "@rigour-labs/core";
+import { randomUUID } from "crypto";
+import {
+    GateRunner,
+    ConfigSchema,
+    Report,
+} from "@rigour-labs/core";
+import {
+    PatternMatcher,
+    loadPatternIndex,
+    getDefaultIndexPath,
+    StalenessDetector,
+    SecurityDetector
+} from "@rigour-labs/core/pattern-index";
 
 const server = new Server(
     {
@@ -56,6 +68,23 @@ async function saveMemory(cwd: string, store: MemoryStore): Promise<void> {
     await fs.writeFile(memPath, JSON.stringify(store, null, 2));
 }
 
+// Helper to log events for Rigour Studio
+async function logStudioEvent(cwd: string, event: any) {
+    try {
+        const rigourDir = path.join(cwd, ".rigour");
+        await fs.ensureDir(rigourDir);
+        const eventsPath = path.join(rigourDir, "events.jsonl");
+        const logEntry = JSON.stringify({
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            ...event
+        }) + "\n";
+        await fs.appendFile(eventsPath, logEntry);
+    } catch {
+        // Silent fail - Studio logging is non-blocking and zero-telemetry
+    }
+}
+
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
@@ -201,6 +230,46 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["cwd", "key"],
                 },
             },
+            {
+                name: "rigour_check_pattern",
+                description: "Checks if a proposed code pattern (function, component, etc.) already exists, is stale, or has security vulnerabilities (CVEs). CALL THIS BEFORE CREATING NEW CODE.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        name: {
+                            type: "string",
+                            description: "The name of the function, class, or component you want to create.",
+                        },
+                        type: {
+                            type: "string",
+                            description: "The type of pattern (e.g., 'function', 'component', 'hook', 'type').",
+                        },
+                        intent: {
+                            type: "string",
+                            description: "What the code is for (e.g., 'format dates', 'user authentication').",
+                        },
+                    },
+                    required: ["cwd", "name"],
+                },
+            },
+            {
+                name: "rigour_security_audit",
+                description: "Runs a live security audit (CVE check) on the project dependencies.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                    },
+                    required: ["cwd"],
+                },
+            },
         ],
     };
 });
@@ -208,15 +277,25 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const cwd = (args as any)?.cwd || process.cwd();
+    const requestId = randomUUID();
 
     try {
+        await logStudioEvent(cwd, {
+            type: "tool_call",
+            requestId,
+            tool: name,
+            arguments: args
+        });
+
         const config = await loadConfig(cwd);
         const runner = new GateRunner(config);
 
+        let result: any;
+
         switch (name) {
             case "rigour_check": {
                 const report = await runner.run(cwd);
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -224,12 +303,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+
+                // Add the report to the tool_response log for high-fidelity Studio visualization
+                (result as any)._rigour_report = report;
+                break;
             }
 
             case "rigour_explain": {
                 const report = await runner.run(cwd);
                 if (report.status === "PASS") {
-                    return {
+                    result = {
                         content: [
                             {
                                 type: "text",
@@ -237,25 +320,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             },
                         ],
                     };
-                }
-
-                const bullets = report.failures.map((f, i) => {
-                    return `${i + 1}. [${f.id.toUpperCase()}] ${f.title}: ${f.details}${f.hint ? ` (Hint: ${f.hint})` : ''}`;
-                }).join("\n");
+                } else {
+                    const bullets = report.failures.map((f, i) => {
+                        return `${i + 1}. [${f.id.toUpperCase()}] ${f.title}: ${f.details}${f.hint ? ` (Hint: ${f.hint})` : ''}`;
+                    }).join("\n");
 
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `RIGOUR EXPLAIN:\n\n${bullets}`,
-                        },
-                    ],
-                };
+                    result = {
+                        content: [
+                            {
+                                type: "text",
+                                text: `RIGOUR EXPLAIN:\n\n${bullets}`,
+                            },
+                        ],
+                    };
+                }
+                break;
             }
 
             case "rigour_status": {
                 const report = await runner.run(cwd);
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -268,12 +352,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             }
 
             case "rigour_get_fix_packet": {
                 const report = await runner.run(cwd);
                 if (report.status === "PASS") {
-                    return {
+                    result = {
                         content: [
                             {
                                 type: "text",
@@ -281,32 +366,33 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             },
                         ],
                     };
+                } else {
+                    const packet = report.failures.map((f, i) => {
+                        let text = `FIX TASK ${i + 1}: [${f.id.toUpperCase()}] ${f.title}\n`;
+                        text += `   - CONTEXT: ${f.details}\n`;
+                        if (f.files && f.files.length > 0) {
+                            text += `   - TARGET FILES: ${f.files.join(", ")}\n`;
+                        }
+                        if (f.hint) {
+                            text += `   - REFACTORING GUIDANCE: ${f.hint}\n`;
+                        }
+                        return text;
+                    }).join("\n---\n");
+
+                    result = {
+                        content: [
+                            {
+                                type: "text",
+                                text: `ENGINEERING REFINEMENT REQUIRED:\n\nThe project state violated ${report.failures.length} quality gates. You MUST address these failures before declaring the task complete:\n\n${packet}`,
+                            },
+                        ],
+                    };
                 }
-
-                const packet = report.failures.map((f, i) => {
-                    let text = `FIX TASK ${i + 1}: [${f.id.toUpperCase()}] ${f.title}\n`;
-                    text += `   - CONTEXT: ${f.details}\n`;
-                    if (f.files && f.files.length > 0) {
-                        text += `   - TARGET FILES: ${f.files.join(", ")}\n`;
-                    }
-                    if (f.hint) {
-                        text += `   - REFACTORING GUIDANCE: ${f.hint}\n`;
-                    }
-                    return text;
-                }).join("\n---\n");
-
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `ENGINEERING REFINEMENT REQUIRED:\n\nThe project state violated ${report.failures.length} quality gates. You MUST address these failures before declaring the task complete:\n\n${packet}`,
-                        },
-                    ],
-                };
+                break;
             }
 
             case "rigour_list_gates":
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -319,9 +405,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
 
             case "rigour_get_config":
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -329,6 +416,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
 
             case "rigour_remember": {
                 const { key, value } = args as any;
@@ -338,7 +426,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     timestamp: new Date().toISOString(),
                 };
                 await saveMemory(cwd, store);
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -346,6 +434,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             }
 
             case "rigour_recall": {
@@ -355,7 +444,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (key) {
                     const memory = store.memories[key];
                     if (!memory) {
-                        return {
+                        result = {
                             content: [
                                 {
                                     type: "text",
@@ -363,77 +452,183 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 },
                             ],
                         };
+                    } else {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})`,
+                                },
+                            ],
+                        };
+                    }
+                } else {
+                    const keys = Object.keys(store.memories);
+                    if (keys.length === 0) {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "NO MEMORIES STORED. Use rigour_remember to persist important instructions.",
+                                },
+                            ],
+                        };
+                    } else {
+                        const allMemories = keys.map(k => {
+                            const mem = store.memories[k];
+                            return `## ${k}\n${mem.value}\n(Stored: ${mem.timestamp})`;
+                        }).join("\n\n---\n\n");
+
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `RECALLED ALL MEMORIES (${keys.length} items):\n\n${allMemories}\n\n---\nIMPORTANT: Follow these stored instructions throughout this session.`,
+                                },
+                            ],
+                        };
                     }
-                    return {
+                }
+                break;
+            }
+
+            case "rigour_forget": {
+                const { key } = args as any;
+                const store = await loadMemory(cwd);
+
+                if (!store.memories[key]) {
+                    result = {
                         content: [
                             {
                                 type: "text",
-                                text: `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})`,
+                                text: `NO MEMORY FOUND for key "${key}". Nothing to forget.`,
                             },
                         ],
                     };
-                }
+                } else {
+                    delete store.memories[key];
+                    await saveMemory(cwd, store);
 
-                const keys = Object.keys(store.memories);
-                if (keys.length === 0) {
-                    return {
+                    result = {
                         content: [
                             {
                                 type: "text",
-                                text: "NO MEMORIES STORED. Use rigour_remember to persist important instructions.",
+                                text: `MEMORY DELETED: "${key}" has been removed.`,
                             },
                         ],
                     };
                 }
+                break;
+            }
+
+            case "rigour_check_pattern": {
+                const { name: patternName, type, intent } = args as any;
+                const indexPath = getDefaultIndexPath(cwd);
+                const index = await loadPatternIndex(indexPath);
+
+                let resultText = "";
+
+                // 1. Check for Reinvention
+                if (index) {
+                    const matcher = new PatternMatcher(index);
+                    const matchResult = await matcher.match({ name: patternName, type, intent });
+
+                    if (matchResult.status === "FOUND_SIMILAR") {
+                        resultText += `🚨 PATTERN REINVENTION DETECTED\n`;
+                        resultText += `Similar pattern already exists: "${matchResult.matches[0].pattern.name}" in ${matchResult.matches[0].pattern.file}\n`;
+                        resultText += `SUGGESTION: ${matchResult.suggestion}\n\n`;
+                    }
+                } else {
+                    resultText += `⚠️ Pattern index not found. Run 'rigour index' to enable reinvention detection.\n\n`;
+                }
 
-                const allMemories = keys.map(k => {
-                    const mem = store.memories[k];
-                    return `## ${k}\n${mem.value}\n(Stored: ${mem.timestamp})`;
-                }).join("\n\n---\n\n");
+                // 2. Check for Staleness/Best Practices
+                const detector = new StalenessDetector(cwd);
+                const staleness = await detector.checkStaleness(`${type || 'function'} ${patternName} {}`);
+
+                if (staleness.status !== "FRESH") {
+                    resultText += `⚠️ STALENESS/ANTI-PATTERN WARNING\n`;
+                    for (const issue of staleness.issues) {
+                        resultText += `- ${issue.reason}\n  REPLACEMENT: ${issue.replacement}\n`;
+                    }
+                    resultText += `\n`;
+                }
+
+                // 3. Check Security for this library (if it's an import)
+                if (intent && intent.includes('import')) {
+                    const security = new SecurityDetector(cwd);
+                    const audit = await security.runAudit();
+                    const relatedVulns = audit.vulnerabilities.filter(v =>
+                        patternName.toLowerCase().includes(v.packageName.toLowerCase()) ||
+                        intent.toLowerCase().includes(v.packageName.toLowerCase())
+                    );
+
+                    if (relatedVulns.length > 0) {
+                        resultText += `🛡️ SECURITY/CVE WARNING\n`;
+                        for (const v of relatedVulns) {
+                            resultText += `- [${v.severity.toUpperCase()}] ${v.packageName}: ${v.title} (${v.url})\n`;
+                        }
+                        resultText += `\n`;
+                    }
+                }
 
-                return {
+                if (!resultText) {
+                    resultText = `✅ Pattern "${patternName}" is fresh, secure, and unique to the codebase.\n\nRECOMMENDED ACTION: Proceed with implementation.`;
+                } else {
+                    let recommendation = "Proceed with caution, addressing the warnings above.";
+                    if (resultText.includes("🚨 PATTERN REINVENTION")) {
+                        recommendation = "STOP and REUSE the existing pattern mentioned above. Do not create a duplicate.";
+                    } else if (resultText.includes("🛡️ SECURITY/CVE WARNING")) {
+                        recommendation = "STOP and update your dependencies or find an alternative library. Do not proceed with vulnerable code.";
+                    } else if (resultText.includes("⚠️ STALENESS")) {
+                        recommendation = "Follow the replacement suggestion to ensure best practices.";
+                    }
+
+                    resultText += `\nRECOMMENDED ACTION: ${recommendation}`;
+                }
+
+                result = {
                     content: [
                         {
                             type: "text",
-                            text: `RECALLED ALL MEMORIES (${keys.length} items):\n\n${allMemories}\n\n---\nIMPORTANT: Follow these stored instructions throughout this session.`,
+                            text: resultText,
                         },
                     ],
                 };
+                break;
             }
 
-            case "rigour_forget": {
-                const { key } = args as any;
-                const store = await loadMemory(cwd);
-
-                if (!store.memories[key]) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `NO MEMORY FOUND for key "${key}". Nothing to forget.`,
-                            },
-                        ],
-                    };
-                }
-
-                delete store.memories[key];
-                await saveMemory(cwd, store);
-
-                return {
+            case "rigour_security_audit": {
+                const security = new SecurityDetector(cwd);
+                const summary = await security.getSecuritySummary();
+                result = {
                     content: [
                         {
                             type: "text",
-                            text: `MEMORY DELETED: "${key}" has been removed.`,
+                            text: summary,
                         },
                     ],
                 };
+                break;
             }
 
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
+
+        await logStudioEvent(cwd, {
+            type: "tool_response",
+            requestId,
+            tool: name,
+            status: "success",
+            content: result.content,
+            _rigour_report: (result as any)._rigour_report
+        });
+
+        return result;
+
     } catch (error: any) {
-        return {
+        const errorResponse = {
             content: [
                 {
                     type: "text",
@@ -442,6 +637,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             ],
             isError: true,
         };
+
+        await logStudioEvent(cwd, {
+            type: "tool_response",
+            requestId,
+            tool: name,
+            status: "error",
+            error: error.message,
+            content: errorResponse.content
+        });
+
+        return errorResponse;
     }
 });