@rigour-labs/mcp 5.5.3 → 6.0.0

package/dist/index.js

@@ -136,7 +136,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 break;
             case "rigour_run_supervised": {
                 const { command, maxRetries = 3, dryRun = false } = args;
-                result = await handleRunSupervised(runner, cwd, command, maxRetries, dryRun, requestId, config);
+                result = await handleRunSupervised({
+                    runner,
+                    cwd,
+                    command,
+                    maxRetries,
+                    dryRun,
+                    requestId,
+                    config,
+                });
                 break;
             }
             // Multi-agent governance

package/dist/tools/agent-handlers.js

@@ -82,6 +82,46 @@ async function validateTaskScopeAgainstIndex(cwd, taskScope) {
 }
 // ─── Agent Register ───────────────────────────────────────────────
 export async function handleAgentRegister(cwd, agentId, taskScope, requestId) {
+    const { validateAgentClaimedScope, loadOperatorScopes, isScopeSubset, } = await import('@rigour-labs/core');
+    const authority = process.env.RIGOUR_ALLOW_AGENT_SCOPE_AUTHORITY === '1';
+    if (!authority) {
+        const claimCheck = validateAgentClaimedScope(taskScope);
+        if (!claimCheck.ok) {
+            await logStudioEvent(cwd, {
+                type: 'firewall_deny',
+                requestId,
+                tool: 'rigour_agent_register',
+                decision: 'deny',
+                reason: claimCheck.reason,
+                ruleId: 'scope.register-denied',
+            });
+            return {
+                content: [{ type: 'text', text: `❌ SCOPE REGISTER DENIED: ${claimCheck.reason}` }],
+                isError: true,
+            };
+        }
+    }
+    const operatorScopes = await loadOperatorScopes(cwd);
+    if (operatorScopes) {
+        const allowed = operatorScopes[agentId];
+        if (!allowed || !isScopeSubset(taskScope, allowed)) {
+            const msg = allowed
+                ? `Claimed scope is not a subset of operator scopes for "${agentId}": ${allowed.join(', ')}`
+                : `No operator scopes defined for agent "${agentId}" in .rigour/operator-scopes.json`;
+            await logStudioEvent(cwd, {
+                type: 'firewall_deny',
+                requestId,
+                tool: 'rigour_agent_register',
+                decision: 'deny',
+                reason: msg,
+                ruleId: 'scope.operator-required',
+            });
+            return {
+                content: [{ type: 'text', text: `❌ SCOPE REGISTER DENIED: ${msg}` }],
+                isError: true,
+            };
+        }
+    }
     const sessionPath = path.join(cwd, '.rigour', 'agent-session.json');
     let session = { agents: [], startedAt: new Date().toISOString() };
     if (await fs.pathExists(sessionPath)) {

package/dist/tools/execution-handlers.d.ts

@@ -8,5 +8,17 @@ type ToolResult = {
     isError?: boolean;
 };
 export declare function handleRun(cwd: string, command: string, requestId: string): Promise<ToolResult>;
-export declare function handleRunSupervised(runner: GateRunner, cwd: string, command: string, maxRetries: number, dryRun: boolean, requestId: string, config?: Config): Promise<ToolResult>;
+export declare function handleRunSupervised(opts: {
+    runner: GateRunner;
+    cwd: string;
+    command: string;
+    maxRetries: number;
+    dryRun: boolean;
+    requestId: string;
+    config?: Config;
+}): Promise<ToolResult>;
+/**
+ * Fail-closed: timeout with no human decision → timeout-deny (not approve).
+ */
+export declare function pollArbitration(cwd: string, rid: string, timeout: number): Promise<string | null>;
 export {};

package/dist/tools/execution-handlers.js

@@ -2,35 +2,76 @@
  * Execution & Supervision Tool Handlers
  *
  * Handlers for: rigour_run, rigour_run_supervised
- *
- * @since v2.17.0 — extracted from monolithic index.ts
+ * Agent Transaction Firewall: fail-closed arbitration + typed commands.
  */
 import fs from "fs-extra";
 import path from "path";
-import { FixPacketService } from "@rigour-labs/core";
+import { FixPacketService, runTypedCommand, evaluateTypedCommand, issueArbitrationToken, } from "@rigour-labs/core";
 import { logStudioEvent } from '../utils/config.js';
 import { notifyProgress } from '../utils/notifications.js';
-export async function handleRun(cwd, command, requestId) {
-    // 1. Log Interceptable Event
+async function requireHumanApproval(cwd, command, requestId, tool) {
+    const arbitrationToken = await issueArbitrationToken(cwd, requestId, 60_000);
     await logStudioEvent(cwd, {
         type: "interception_requested",
         requestId,
-        tool: "rigour_run",
+        tool,
         command,
+        arbitrationToken,
     });
-    // 2. Poll for Human Arbitration (Max 60s wait)
     console.error(`[RIGOUR] Waiting for human arbitration for command: ${command}`);
     const decision = await pollArbitration(cwd, requestId, 60000);
-    if (decision === 'reject') {
+    if (decision === 'approve')
+        return null;
+    await logStudioEvent(cwd, {
+        type: "firewall_deny",
+        requestId,
+        tool: "human_arbitration",
+        decision: decision ?? 'timeout-deny',
+        reason: decision === 'reject' ? 'Human rejected' : 'Arbitration timed out (fail-closed)',
+    });
+    return {
+        content: [{
+                type: "text",
+                text: decision === 'reject'
+                    ? `❌ COMMAND REJECTED BY GOVERNOR: The execution of "${command}" was blocked by a human operator in the Governance Studio.`
+                    : `❌ COMMAND DENIED (fail-closed): No human arbitration within 60s for "${command}".`,
+            }],
+        isError: true,
+    };
+}
+export async function handleRun(cwd, command, requestId) {
+    const typed = evaluateTypedCommand(command);
+    await logStudioEvent(cwd, {
+        type: "firewall_precheck",
+        requestId,
+        tool: "rigour_run",
+        command,
+        firewallDecision: typed.decision,
+        firewallReason: typed.reason,
+        ruleId: typed.ruleId,
+    });
+    if (typed.decision !== 'allow') {
+        await logStudioEvent(cwd, {
+            type: "firewall_deny",
+            requestId,
+            tool: "rigour_run",
+            decision: typed.decision,
+            reason: typed.reason,
+            ruleId: typed.ruleId,
+        });
         return {
-            content: [{ type: "text", text: `❌ COMMAND REJECTED BY GOVERNOR: The execution of "${command}" was blocked by a human operator in the Governance Studio.` }],
+            content: [{
+                    type: "text",
+                    text: `❌ FIREWALL DENY (${typed.ruleId}): ${typed.reason}\nCommand: ${command}`,
+                }],
             isError: true,
         };
     }
-    // Execute
-    const { execa } = await import("execa");
+    const denied = await requireHumanApproval(cwd, command, requestId, "rigour_run");
+    if (denied)
+        return denied;
     try {
-        const { stdout, stderr } = await execa(command, { shell: true, cwd });
+        const { stdout, stderr } = await runTypedCommand(command, cwd);
         return {
             content: [{ type: "text", text: `✅ COMMAND EXECUTED (Approved by Governor):\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${stderr}` }],
         };
@@ -42,8 +83,29 @@ export async function handleRun(cwd, command, requestId) {
         };
     }
 }
-export async function handleRunSupervised(runner, cwd, command, maxRetries, dryRun, requestId, config) {
-    const { execa } = await import("execa");
+export async function handleRunSupervised(opts) {
+    const { runner, cwd, command, maxRetries, dryRun, requestId, config } = opts;
+    const typed = evaluateTypedCommand(command);
+    if (typed.decision !== 'allow') {
+        await logStudioEvent(cwd, {
+            type: "firewall_deny",
+            requestId,
+            tool: "rigour_run_supervised",
+            decision: typed.decision,
+            reason: typed.reason,
+            ruleId: typed.ruleId,
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: `❌ FIREWALL DENY (${typed.ruleId}): ${typed.reason}\nCommand: ${command}`,
+                }],
+            isError: true,
+        };
+    }
+    const denied = await requireHumanApproval(cwd, command, requestId, "rigour_run_supervised");
+    if (denied)
+        return denied;
     let iteration = 0;
     let lastReport = null;
     let result = null;
@@ -61,7 +123,7 @@ export async function handleRunSupervised(runner, cwd, command, maxRetries, dryR
         notifyProgress("info", `Supervisor iteration ${iteration}/${maxRetries}...`);
         if (!dryRun) {
             try {
-                await execa(command, { shell: true, cwd });
+                await runTypedCommand(command, cwd);
             }
             catch (e) {
                 console.error(`[RIGOUR] Iteration ${iteration} command error: ${e.message}`);
@@ -99,7 +161,6 @@ export async function handleRunSupervised(runner, cwd, command, maxRetries, dryR
         }
         if (iteration >= maxRetries) {
             notifyProgress("error", `Supervisor FAILED after ${iteration} iterations \u2014 ${lastReport.failures.length} violations remain`);
-            // Use FixPacketService for structured output instead of ad-hoc formatting
             let fixPacketText;
             if (config) {
                 const fixPacketService = new FixPacketService();
@@ -107,7 +168,6 @@ export async function handleRunSupervised(runner, cwd, command, maxRetries, dryR
                 fixPacketText = formatFixPacketForSupervisor(fixPacket);
             }
             else {
-                // Fallback if config not available
                 fixPacketText = lastReport.failures.map((f, i) => {
                     const sevTag = `[${(f.severity || 'medium').toUpperCase()}]`;
                     return `${i + 1}. ${sevTag} [${f.id}] ${f.title}: ${f.details}${f.files?.length ? ` (${f.files.join(', ')})` : ''}`;
@@ -168,28 +228,44 @@ function formatFixPacketForSupervisor(fixPacket) {
     }
     return lines.join('\n');
 }
-// ─── Private Helpers ──────────────────────────────────────────────
-async function pollArbitration(cwd, rid, timeout) {
-    const start = Date.now();
+/**
+ * Fail-closed: timeout with no human decision → timeout-deny (not approve).
+ */
+export async function pollArbitration(cwd, rid, timeout) {
     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()) {
-                let event;
-                try {
-                    event = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                if (event.tool === 'human_arbitration' && event.requestId === rid) {
-                    return event.decision;
-                }
-            }
+    const maxIterations = Math.max(1, Math.ceil(timeout / 1000));
+    for (let i = 0; i < maxIterations; i++) {
+        const found = await readArbitrationDecision(eventsPath, rid);
+        if (found)
+            return found;
+        await sleepMs(1000);
+    }
+    return "timeout-deny";
+}
+async function readArbitrationDecision(eventsPath, rid) {
+    if (!(await fs.pathExists(eventsPath)))
+        return null;
+    const content = await fs.readFile(eventsPath, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim());
+    for (const line of lines.reverse()) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (event.tool === 'human_arbitration' && event.requestId === rid) {
+            return event.decision;
         }
-        await new Promise(r => setTimeout(r, 1000));
     }
-    return "approve"; // Default auto-approve if no human response
+    return null;
+}
+function sleepMs(ms) {
+    return new Promise(resolve => {
+        const timerId = setTimeout(() => {
+            clearTimeout(timerId);
+            resolve();
+        }, ms);
+    });
 }

package/dist/tools/hooks-handler.js

@@ -73,6 +73,8 @@ export async function handleHooksCheck(cwd, files, timeout, text, agent) {
     const input = { cwd, files };
     if (timeout)
         input.timeout_ms = timeout;
+    if (agent)
+        input.agentId = agent;
     const result = await runHookChecker(input);
     if (result.status === 'pass') {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/mcp",
-  "version": "5.5.3",
+  "version": "6.0.0",
   "description": "MCP server + live dashboard for AI code governance — OWASP LLM Top 10 (10/10), real-time MCP App UI, 25+ security patterns, Bayesian learning Brain, hallucinated import detection, multi-agent governance. Works with Claude, Cursor, VS Code, ChatGPT, Goose, Windsurf. Industry presets for HIPAA, SOC2, FedRAMP.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -62,7 +62,7 @@
     "execa": "^8.0.1",
     "fs-extra": "^11.4.0",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "5.5.3"
+    "@rigour-labs/core": "6.0.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",