@rigour-labs/mcp 2.10.0 → 2.12.0

package/dist/index.js

@@ -1,18 +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 pattern_index_1 = require("@rigour-labs/core/pattern-index");
-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",
 }, {
@@ -21,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: [
             {
@@ -230,19 +243,49 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
                     required: ["cwd"],
                 },
             },
+            {
+                name: "rigour_run",
+                description: "Execute a command under Rigour supervision. This tool can be INTERCEPTED and ARBITRATED by the Governance Studio.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        command: {
+                            type: "string",
+                            description: "The command to run (e.g., 'npm test', 'pytest').",
+                        },
+                        silent: {
+                            type: "boolean",
+                            description: "If true, hides the command output from the agent.",
+                        }
+                    },
+                    required: ["cwd", "command"],
+                },
+            }
         ],
     };
 });
-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",
@@ -250,11 +293,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",
@@ -263,21 +309,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",
@@ -290,11 +339,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",
@@ -303,28 +353,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",
@@ -337,8 +390,9 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             case "rigour_get_config":
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -346,6 +400,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             case "rigour_remember": {
                 const { key, value } = args;
                 const store = await loadMemory(cwd);
@@ -354,7 +409,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     timestamp: new Date().toISOString(),
                 };
                 await saveMemory(cwd, store);
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -362,6 +417,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             }
             case "rigour_recall": {
                 const { key } = args;
@@ -369,7 +425,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 if (key) {
                     const memory = store.memories[key];
                     if (!memory) {
-                        return {
+                        result = {
                             content: [
                                 {
                                     type: "text",
@@ -378,44 +434,51 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             ],
                         };
                     }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})`,
-                            },
-                        ],
-                    };
+                    else {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})`,
+                                },
+                            ],
+                        };
+                    }
                 }
-                const keys = Object.keys(store.memories);
-                if (keys.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "NO MEMORIES STORED. Use rigour_remember to persist important instructions.",
-                            },
-                        ],
-                    };
+                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.`,
+                                },
+                            ],
+                        };
+                    }
                 }
-                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 {
-                    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]) {
-                    return {
+                    result = {
                         content: [
                             {
                                 type: "text",
@@ -424,25 +487,28 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         ],
                     };
                 }
-                delete store.memories[key];
-                await saveMemory(cwd, store);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `MEMORY DELETED: "${key}" has been removed.`,
-                        },
-                    ],
-                };
+                else {
+                    delete store.memories[key];
+                    await saveMemory(cwd, store);
+                    result = {
+                        content: [
+                            {
+                                type: "text",
+                                text: `MEMORY DELETED: "${key}" has been removed.`,
+                            },
+                        ],
+                    };
+                }
+                break;
             }
             case "rigour_check_pattern": {
                 const { name: patternName, type, intent } = args;
-                const indexPath = (0, pattern_index_1.getDefaultIndexPath)(cwd);
-                const index = await (0, pattern_index_1.loadPatternIndex)(indexPath);
+                const indexPath = getDefaultIndexPath(cwd);
+                const index = await loadPatternIndex(indexPath);
                 let resultText = "";
                 // 1. Check for Reinvention
                 if (index) {
-                    const matcher = new pattern_index_1.PatternMatcher(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`;
@@ -454,7 +520,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     resultText += `⚠️ Pattern index not found. Run 'rigour index' to enable reinvention detection.\n\n`;
                 }
                 // 2. Check for Staleness/Best Practices
-                const detector = new pattern_index_1.StalenessDetector(cwd);
+                const detector = new StalenessDetector(cwd);
                 const staleness = await detector.checkStaleness(`${type || 'function'} ${patternName} {}`);
                 if (staleness.status !== "FRESH") {
                     resultText += `⚠️ STALENESS/ANTI-PATTERN WARNING\n`;
@@ -465,7 +531,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 }
                 // 3. Check Security for this library (if it's an import)
                 if (intent && intent.includes('import')) {
-                    const security = new pattern_index_1.SecurityDetector(cwd);
+                    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()));
@@ -493,7 +559,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     }
                     resultText += `\nRECOMMENDED ACTION: ${recommendation}`;
                 }
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -501,11 +567,12 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             }
             case "rigour_security_audit": {
-                const security = new pattern_index_1.SecurityDetector(cwd);
+                const security = new SecurityDetector(cwd);
                 const summary = await security.getSecuritySummary();
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -513,13 +580,93 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
+            }
+            case "rigour_run": {
+                const { command } = args;
+                // 1. Log Interceptable Event
+                await logStudioEvent(cwd, {
+                    type: "interception_requested",
+                    requestId: requestId,
+                    tool: "rigour_run",
+                    command
+                });
+                // 2. Poll for Human Arbitration (Max 60s wait for this demo/test)
+                // In production, this would be a blocking call wait
+                console.error(`[RIGOUR] Waiting for human arbitration for command: ${command}`);
+                const pollArbitration = async (rid, timeout) => {
+                    const start = Date.now();
+                    const eventsPath = path.join(cwd, '.rigour/events.jsonl');
+                    while (Date.now() - start < timeout) {
+                        if (await fs.pathExists(eventsPath)) {
+                            const content = await fs.readFile(eventsPath, 'utf-8');
+                            const lines = content.split('\n').filter(l => l.trim());
+                            for (const line of lines.reverse()) {
+                                const event = JSON.parse(line);
+                                if (event.tool === 'human_arbitration' && event.requestId === rid) {
+                                    return event.decision;
+                                }
+                            }
+                        }
+                        await new Promise(r => setTimeout(r, 1000));
+                    }
+                    return "approve"; // Default to auto-approve if no human response (for non-blocking feel)
+                };
+                const decision = await pollArbitration(requestId, 60000);
+                if (decision === 'reject') {
+                    result = {
+                        content: [
+                            {
+                                type: "text",
+                                text: `❌ COMMAND REJECTED BY GOVERNOR: The execution of "${command}" was blocked by a human operator in the Governance Studio.`,
+                            },
+                        ],
+                        isError: true
+                    };
+                }
+                else {
+                    // Execute
+                    const { execa } = await import("execa");
+                    try {
+                        const { stdout, stderr } = await execa(command, { shell: true, cwd });
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `✅ COMMAND EXECUTED (Approved by Governor):\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${stderr}`,
+                                },
+                            ],
+                        };
+                    }
+                    catch (e) {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `❌ COMMAND FAILED:\n\n${e.message}`,
+                                },
+                            ],
+                            isError: true
+                        };
+                    }
+                }
+                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",
@@ -528,10 +675,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.10.0",
+  "version": "2.12.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": {
@@ -16,9 +17,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.2",
+    "execa": "^8.0.1",
     "fs-extra": "^11.2.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "2.10.0"
+    "@rigour-labs/core": "2.12.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.3"

package/src/index.ts

@@ -8,6 +8,7 @@ import {
 import fs from "fs-extra";
 import path from "path";
 import yaml from "yaml";
+import { randomUUID } from "crypto";
 import {
     GateRunner,
     ConfigSchema,
@@ -67,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: [
@@ -252,6 +270,28 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["cwd"],
                 },
             },
+            {
+                name: "rigour_run",
+                description: "Execute a command under Rigour supervision. This tool can be INTERCEPTED and ARBITRATED by the Governance Studio.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        command: {
+                            type: "string",
+                            description: "The command to run (e.g., 'npm test', 'pytest').",
+                        },
+                        silent: {
+                            type: "boolean",
+                            description: "If true, hides the command output from the agent.",
+                        }
+                    },
+                    required: ["cwd", "command"],
+                },
+            }
         ],
     };
 });
@@ -259,15 +299,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",
@@ -275,12 +325,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",
@@ -288,25 +342,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",
@@ -319,12 +374,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",
@@ -332,32 +388,33 @@ server.setRequestHandler(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");
+                } 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");
 
-                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}`,
-                        },
-                    ],
-                };
+                    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",
@@ -370,9 +427,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
 
             case "rigour_get_config":
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -380,6 +438,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
 
             case "rigour_remember": {
                 const { key, value } = args as any;
@@ -389,7 +448,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     timestamp: new Date().toISOString(),
                 };
                 await saveMemory(cwd, store);
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -397,6 +456,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             }
 
             case "rigour_recall": {
@@ -406,7 +466,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (key) {
                     const memory = store.memories[key];
                     if (!memory) {
-                        return {
+                        result = {
                             content: [
                                 {
                                     type: "text",
@@ -414,42 +474,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 },
                             ],
                         };
+                    } else {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})`,
+                                },
+                            ],
+                        };
                     }
-                    return {
-                        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");
 
-                const keys = Object.keys(store.memories);
-                if (keys.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "NO MEMORIES STORED. Use rigour_remember to persist important instructions.",
-                            },
-                        ],
-                    };
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `RECALLED ALL MEMORIES (${keys.length} items):\n\n${allMemories}\n\n---\nIMPORTANT: Follow these stored instructions throughout this session.`,
+                                },
+                            ],
+                        };
+                    }
                 }
-
-                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 {
-                    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": {
@@ -457,7 +519,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const store = await loadMemory(cwd);
 
                 if (!store.memories[key]) {
-                    return {
+                    result = {
                         content: [
                             {
                                 type: "text",
@@ -465,19 +527,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             },
                         ],
                     };
-                }
-
-                delete store.memories[key];
-                await saveMemory(cwd, store);
+                } else {
+                    delete store.memories[key];
+                    await saveMemory(cwd, store);
 
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `MEMORY DELETED: "${key}" has been removed.`,
-                        },
-                    ],
-                };
+                    result = {
+                        content: [
+                            {
+                                type: "text",
+                                text: `MEMORY DELETED: "${key}" has been removed.`,
+                            },
+                        ],
+                    };
+                }
+                break;
             }
 
             case "rigour_check_pattern": {
@@ -546,7 +609,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     resultText += `\nRECOMMENDED ACTION: ${recommendation}`;
                 }
 
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -554,12 +617,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
             }
 
             case "rigour_security_audit": {
                 const security = new SecurityDetector(cwd);
                 const summary = await security.getSecuritySummary();
-                return {
+                result = {
                     content: [
                         {
                             type: "text",
@@ -567,13 +631,100 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+                break;
+            }
+
+            case "rigour_run": {
+                const { command } = args as any;
+
+                // 1. Log Interceptable Event
+                await logStudioEvent(cwd, {
+                    type: "interception_requested",
+                    requestId: requestId,
+                    tool: "rigour_run",
+                    command
+                });
+
+                // 2. Poll for Human Arbitration (Max 60s wait for this demo/test)
+                // In production, this would be a blocking call wait
+                console.error(`[RIGOUR] Waiting for human arbitration for command: ${command}`);
+
+                const pollArbitration = async (rid: string, timeout: number): Promise<string | null> => {
+                    const start = Date.now();
+                    const eventsPath = path.join(cwd, '.rigour/events.jsonl');
+                    while (Date.now() - start < timeout) {
+                        if (await fs.pathExists(eventsPath)) {
+                            const content = await fs.readFile(eventsPath, 'utf-8');
+                            const lines = content.split('\n').filter(l => l.trim());
+                            for (const line of lines.reverse()) {
+                                const event = JSON.parse(line);
+                                if (event.tool === 'human_arbitration' && event.requestId === rid) {
+                                    return event.decision;
+                                }
+                            }
+                        }
+                        await new Promise(r => setTimeout(r, 1000));
+                    }
+                    return "approve"; // Default to auto-approve if no human response (for non-blocking feel)
+                };
+
+                const decision = await pollArbitration(requestId, 60000);
+
+                if (decision === 'reject') {
+                    result = {
+                        content: [
+                            {
+                                type: "text",
+                                text: `❌ COMMAND REJECTED BY GOVERNOR: The execution of "${command}" was blocked by a human operator in the Governance Studio.`,
+                            },
+                        ],
+                        isError: true
+                    };
+                } else {
+                    // Execute
+                    const { execa } = await import("execa");
+                    try {
+                        const { stdout, stderr } = await execa(command, { shell: true, cwd });
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `✅ COMMAND EXECUTED (Approved by Governor):\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${stderr}`,
+                                },
+                            ],
+                        };
+                    } catch (e: any) {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `❌ COMMAND FAILED:\n\n${e.message}`,
+                                },
+                            ],
+                            isError: true
+                        };
+                    }
+                }
+                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",
@@ -582,6 +733,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;
     }
 });