@rigour-labs/mcp 2.17.2 → 2.18.1

package/README.md

@@ -24,6 +24,8 @@ Rigour moves code quality enforcement from the "Post-Commit" phase to the "In-Pr
 
 ## 🛠️ Available Tools
 
+### Core Tools
+
 | Tool | Description |
 |:---|:---|
 | `rigour_check` | Runs all configured quality gates on the current workspace. |
@@ -31,6 +33,19 @@ Rigour moves code quality enforcement from the "Post-Commit" phase to the "In-Pr
 | `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. |
+| `rigour_security_audit` | Runs a live CVE check on project dependencies. |
+
+### Frontier Model Tools (v2.14+)
+
+For next-gen multi-agent workflows (Opus 4.6, GPT-5.3-Codex):
+
+| Tool | Description |
+|:---|:---|
+| `rigour_agent_register` | Register agent in session with scope conflict detection. |
+| `rigour_agent_deregister` | Remove agent from session when work is complete. |
+| `rigour_checkpoint` | Record quality checkpoint with drift detection. |
+| `rigour_handoff` | Initiate task handoff to another agent. |
+| `rigour_handoff_accept` | Accept a pending handoff from another agent. |
 
 ---
 

package/dist/index.js

@@ -273,6 +273,163 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     required: ["cwd", "command"],
                 },
+            },
+            {
+                name: "rigour_run_supervised",
+                description: "Run a command under FULL Supervisor Mode. Iteratively executes the command, checks quality gates, and returns fix packets until PASS or max retries reached. Use this for self-healing agent loops.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        command: {
+                            type: "string",
+                            description: "The agent command to run (e.g., 'claude \"fix the bug\"', 'aider --message \"refactor auth\"').",
+                        },
+                        maxRetries: {
+                            type: "number",
+                            description: "Maximum retry iterations (default: 3).",
+                        },
+                        dryRun: {
+                            type: "boolean",
+                            description: "If true, simulates the loop without executing the command. Useful for testing gate checks.",
+                        },
+                    },
+                    required: ["cwd", "command"],
+                },
+            },
+            // === FRONTIER MODEL TOOLS (v2.14+) ===
+            // For Opus 4.6, GPT-5.3-Codex multi-agent and long-running sessions
+            {
+                name: "rigour_agent_register",
+                description: "Register an agent in a multi-agent session. Use this at the START of agent execution to claim task scope and enable cross-agent conflict detection. Required for Agent Team Governance.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        agentId: {
+                            type: "string",
+                            description: "Unique identifier for this agent (e.g., 'agent-a', 'opus-frontend').",
+                        },
+                        taskScope: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Glob patterns defining the files/directories this agent will work on (e.g., ['src/api/**', 'tests/api/**']).",
+                        },
+                    },
+                    required: ["cwd", "agentId", "taskScope"],
+                },
+            },
+            {
+                name: "rigour_checkpoint",
+                description: "Record a quality checkpoint during long-running agent execution. Use periodically (every 15-30 min) to enable drift detection and quality monitoring. Essential for GPT-5.3 coworking mode.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        progressPct: {
+                            type: "number",
+                            description: "Estimated progress percentage (0-100).",
+                        },
+                        filesChanged: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "List of files modified since last checkpoint.",
+                        },
+                        summary: {
+                            type: "string",
+                            description: "Brief description of work done since last checkpoint.",
+                        },
+                        qualityScore: {
+                            type: "number",
+                            description: "Self-assessed quality score (0-100). Be honest - artificially high scores trigger drift detection.",
+                        },
+                    },
+                    required: ["cwd", "progressPct", "summary", "qualityScore"],
+                },
+            },
+            {
+                name: "rigour_handoff",
+                description: "Handoff task to another agent in a multi-agent workflow. Use when delegating a subtask or completing your scope. Enables verified handoff governance.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        fromAgentId: {
+                            type: "string",
+                            description: "ID of the agent initiating the handoff.",
+                        },
+                        toAgentId: {
+                            type: "string",
+                            description: "ID of the agent receiving the handoff.",
+                        },
+                        taskDescription: {
+                            type: "string",
+                            description: "Description of the task being handed off.",
+                        },
+                        filesInScope: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Files relevant to the handoff.",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Additional context for the receiving agent.",
+                        },
+                    },
+                    required: ["cwd", "fromAgentId", "toAgentId", "taskDescription"],
+                },
+            },
+            {
+                name: "rigour_agent_deregister",
+                description: "Deregister an agent from the multi-agent session. Use when an agent completes its work or needs to release its scope for another agent.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        agentId: {
+                            type: "string",
+                            description: "ID of the agent to deregister.",
+                        },
+                    },
+                    required: ["cwd", "agentId"],
+                },
+            },
+            {
+                name: "rigour_handoff_accept",
+                description: "Accept a pending handoff from another agent. Use to formally acknowledge receipt of a task and verify you are the intended recipient.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        cwd: {
+                            type: "string",
+                            description: "Absolute path to the project root.",
+                        },
+                        handoffId: {
+                            type: "string",
+                            description: "ID of the handoff to accept.",
+                        },
+                        agentId: {
+                            type: "string",
+                            description: "ID of the accepting agent (must match toAgentId in the handoff).",
+                        },
+                    },
+                    required: ["cwd", "handoffId", "agentId"],
+                },
             }
         ],
     };
@@ -661,6 +818,342 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 break;
             }
+            case "rigour_run_supervised": {
+                const { command, maxRetries = 3, dryRun = false } = args;
+                const { execa } = await import("execa");
+                let iteration = 0;
+                let lastReport = null;
+                const iterations = [];
+                await logStudioEvent(cwd, {
+                    type: "supervisor_started",
+                    requestId,
+                    command,
+                    maxRetries,
+                    dryRun
+                });
+                while (iteration < maxRetries) {
+                    iteration++;
+                    // 1. Execute the agent command (skip in dryRun mode)
+                    if (!dryRun) {
+                        try {
+                            await execa(command, { shell: true, cwd });
+                        }
+                        catch (e) {
+                            // Command failure is OK - agent might have partial progress
+                            console.error(`[RIGOUR] Iteration ${iteration} command error: ${e.message}`);
+                        }
+                    }
+                    else {
+                        console.error(`[RIGOUR] Iteration ${iteration} (DRY RUN - skipping command execution)`);
+                    }
+                    // 2. Check quality gates
+                    lastReport = await runner.run(cwd);
+                    iterations.push({
+                        iteration,
+                        status: lastReport.status,
+                        failures: lastReport.failures.length
+                    });
+                    await logStudioEvent(cwd, {
+                        type: "supervisor_iteration",
+                        requestId,
+                        iteration,
+                        status: lastReport.status,
+                        failures: lastReport.failures.length
+                    });
+                    // 3. If PASS, we're done
+                    if (lastReport.status === "PASS") {
+                        result = {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `✅ SUPERVISOR MODE: PASSED on iteration ${iteration}/${maxRetries}\n\nIterations:\n${iterations.map(i => `  ${i.iteration}. ${i.status} (${i.failures} failures)`).join("\n")}\n\nAll quality gates have been satisfied.`,
+                                },
+                            ],
+                        };
+                        break;
+                    }
+                    // 4. If not at max retries, continue the loop (agent will use fix packet next iteration)
+                    if (iteration >= maxRetries) {
+                        // Final failure - return fix packet
+                        const fixPacket = lastReport.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: `❌ SUPERVISOR MODE: FAILED after ${iteration} iterations\n\nIterations:\n${iterations.map(i => `  ${i.iteration}. ${i.status} (${i.failures} failures)`).join("\n")}\n\nFINAL FIX PACKET:\n${fixPacket}`,
+                                },
+                            ],
+                            isError: true
+                        };
+                    }
+                }
+                await logStudioEvent(cwd, {
+                    type: "supervisor_completed",
+                    requestId,
+                    finalStatus: lastReport?.status || "UNKNOWN",
+                    totalIterations: iteration
+                });
+                break;
+            }
+            // === FRONTIER MODEL TOOL HANDLERS (v2.14+) ===
+            case "rigour_agent_register": {
+                const { agentId, taskScope } = args;
+                // Load or create agent session
+                const sessionPath = path.join(cwd, '.rigour', 'agent-session.json');
+                let session = { agents: [], startedAt: new Date().toISOString() };
+                if (await fs.pathExists(sessionPath)) {
+                    session = JSON.parse(await fs.readFile(sessionPath, 'utf-8'));
+                }
+                // Check for existing agent
+                const existingIdx = session.agents.findIndex((a) => a.agentId === agentId);
+                if (existingIdx >= 0) {
+                    session.agents[existingIdx] = {
+                        agentId,
+                        taskScope,
+                        registeredAt: session.agents[existingIdx].registeredAt,
+                        lastCheckpoint: new Date().toISOString(),
+                    };
+                }
+                else {
+                    session.agents.push({
+                        agentId,
+                        taskScope,
+                        registeredAt: new Date().toISOString(),
+                        lastCheckpoint: new Date().toISOString(),
+                    });
+                }
+                // Check for scope conflicts
+                const conflicts = [];
+                for (const agent of session.agents) {
+                    if (agent.agentId !== agentId) {
+                        for (const scope of taskScope) {
+                            if (agent.taskScope.includes(scope)) {
+                                conflicts.push(`${agent.agentId} also claims "${scope}"`);
+                            }
+                        }
+                    }
+                }
+                await fs.ensureDir(path.join(cwd, '.rigour'));
+                await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+                await logStudioEvent(cwd, {
+                    type: "agent_registered",
+                    requestId,
+                    agentId,
+                    taskScope,
+                    conflicts,
+                });
+                let responseText = `✅ AGENT REGISTERED: "${agentId}" claimed scope: ${taskScope.join(', ')}\n\n`;
+                responseText += `Active agents in session: ${session.agents.length}\n`;
+                if (conflicts.length > 0) {
+                    responseText += `\n⚠️ SCOPE CONFLICTS DETECTED:\n${conflicts.map(c => `  - ${c}`).join('\n')}\n`;
+                    responseText += `\nConsider coordinating with other agents or narrowing your scope.`;
+                }
+                result = {
+                    content: [{ type: "text", text: responseText }],
+                };
+                break;
+            }
+            case "rigour_checkpoint": {
+                const { progressPct, filesChanged = [], summary, qualityScore } = args;
+                // Load checkpoint session
+                const checkpointPath = path.join(cwd, '.rigour', 'checkpoint-session.json');
+                let session = {
+                    sessionId: `chk-session-${Date.now()}`,
+                    startedAt: new Date().toISOString(),
+                    checkpoints: [],
+                    status: 'active'
+                };
+                if (await fs.pathExists(checkpointPath)) {
+                    session = JSON.parse(await fs.readFile(checkpointPath, 'utf-8'));
+                }
+                const checkpointId = `cp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const warnings = [];
+                // Quality threshold check
+                if (qualityScore < 80) {
+                    warnings.push(`Quality score ${qualityScore}% is below threshold 80%`);
+                }
+                // Drift detection (quality degrading over time)
+                if (session.checkpoints.length >= 2) {
+                    const recentScores = session.checkpoints.slice(-3).map((cp) => cp.qualityScore);
+                    const avgRecent = recentScores.reduce((a, b) => a + b, 0) / recentScores.length;
+                    if (qualityScore < avgRecent - 10) {
+                        warnings.push(`Drift detected: quality dropped from avg ${avgRecent.toFixed(0)}% to ${qualityScore}%`);
+                    }
+                }
+                const checkpoint = {
+                    checkpointId,
+                    timestamp: new Date().toISOString(),
+                    progressPct,
+                    filesChanged,
+                    summary,
+                    qualityScore,
+                    warnings,
+                };
+                session.checkpoints.push(checkpoint);
+                await fs.ensureDir(path.join(cwd, '.rigour'));
+                await fs.writeFile(checkpointPath, JSON.stringify(session, null, 2));
+                await logStudioEvent(cwd, {
+                    type: "checkpoint_recorded",
+                    requestId,
+                    checkpointId,
+                    progressPct,
+                    qualityScore,
+                    warnings,
+                });
+                let responseText = `📍 CHECKPOINT RECORDED: ${checkpointId}\n\n`;
+                responseText += `Progress: ${progressPct}% | Quality: ${qualityScore}%\n`;
+                responseText += `Summary: ${summary}\n`;
+                responseText += `Total checkpoints: ${session.checkpoints.length}\n`;
+                if (warnings.length > 0) {
+                    responseText += `\n⚠️ WARNINGS:\n${warnings.map(w => `  - ${w}`).join('\n')}\n`;
+                    if (qualityScore < 80) {
+                        responseText += `\n⛔ QUALITY BELOW THRESHOLD: Consider pausing and reviewing recent work.`;
+                    }
+                }
+                const shouldContinue = qualityScore >= 80;
+                result._shouldContinue = shouldContinue;
+                result = {
+                    content: [{ type: "text", text: responseText }],
+                };
+                break;
+            }
+            case "rigour_handoff": {
+                const { fromAgentId, toAgentId, taskDescription, filesInScope = [], context = '' } = args;
+                const handoffId = `handoff-${Date.now()}`;
+                const handoffPath = path.join(cwd, '.rigour', 'handoffs.jsonl');
+                const handoff = {
+                    handoffId,
+                    timestamp: new Date().toISOString(),
+                    fromAgentId,
+                    toAgentId,
+                    taskDescription,
+                    filesInScope,
+                    context,
+                    status: 'pending',
+                };
+                await fs.ensureDir(path.join(cwd, '.rigour'));
+                await fs.appendFile(handoffPath, JSON.stringify(handoff) + '\n');
+                await logStudioEvent(cwd, {
+                    type: "handoff_initiated",
+                    requestId,
+                    handoffId,
+                    fromAgentId,
+                    toAgentId,
+                    taskDescription,
+                });
+                let responseText = `🤝 HANDOFF INITIATED: ${handoffId}\n\n`;
+                responseText += `From: ${fromAgentId} → To: ${toAgentId}\n`;
+                responseText += `Task: ${taskDescription}\n`;
+                if (filesInScope.length > 0) {
+                    responseText += `Files in scope: ${filesInScope.join(', ')}\n`;
+                }
+                if (context) {
+                    responseText += `Context: ${context}\n`;
+                }
+                responseText += `\nThe receiving agent should call rigour_agent_register to claim this scope.`;
+                result = {
+                    content: [{ type: "text", text: responseText }],
+                };
+                break;
+            }
+            case "rigour_agent_deregister": {
+                const { agentId } = args;
+                const sessionPath = path.join(cwd, '.rigour', 'agent-session.json');
+                if (!await fs.pathExists(sessionPath)) {
+                    result = {
+                        content: [{ type: "text", text: `❌ No active agent session found.` }],
+                    };
+                    break;
+                }
+                const session = JSON.parse(await fs.readFile(sessionPath, 'utf-8'));
+                const initialCount = session.agents.length;
+                session.agents = session.agents.filter((a) => a.agentId !== agentId);
+                if (session.agents.length === initialCount) {
+                    result = {
+                        content: [{ type: "text", text: `❌ Agent "${agentId}" not found in session.` }],
+                    };
+                    break;
+                }
+                await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
+                await logStudioEvent(cwd, {
+                    type: "agent_deregistered",
+                    requestId,
+                    agentId,
+                    remainingAgents: session.agents.length,
+                });
+                let responseText = `✅ AGENT DEREGISTERED: "${agentId}" has been removed from the session.\n\n`;
+                responseText += `Remaining agents: ${session.agents.length}\n`;
+                if (session.agents.length > 0) {
+                    responseText += `Active: ${session.agents.map((a) => a.agentId).join(', ')}`;
+                }
+                result = {
+                    content: [{ type: "text", text: responseText }],
+                };
+                break;
+            }
+            case "rigour_handoff_accept": {
+                const { handoffId, agentId } = args;
+                const handoffPath = path.join(cwd, '.rigour', 'handoffs.jsonl');
+                if (!await fs.pathExists(handoffPath)) {
+                    result = {
+                        content: [{ type: "text", text: `❌ No handoffs found.` }],
+                    };
+                    break;
+                }
+                const content = await fs.readFile(handoffPath, 'utf-8');
+                const handoffs = content.trim().split('\n').filter(l => l).map(line => JSON.parse(line));
+                const handoff = handoffs.find((h) => h.handoffId === handoffId);
+                if (!handoff) {
+                    result = {
+                        content: [{ type: "text", text: `❌ Handoff "${handoffId}" not found.` }],
+                    };
+                    break;
+                }
+                if (handoff.toAgentId !== agentId) {
+                    result = {
+                        content: [{
+                                type: "text",
+                                text: `❌ Agent "${agentId}" is not the intended recipient.\nHandoff is for: ${handoff.toAgentId}`
+                            }],
+                        isError: true
+                    };
+                    break;
+                }
+                handoff.status = 'accepted';
+                handoff.acceptedAt = new Date().toISOString();
+                handoff.acceptedBy = agentId;
+                // Rewrite the file with updated handoff
+                const updatedContent = handoffs.map((h) => JSON.stringify(h)).join('\n') + '\n';
+                await fs.writeFile(handoffPath, updatedContent);
+                await logStudioEvent(cwd, {
+                    type: "handoff_accepted",
+                    requestId,
+                    handoffId,
+                    acceptedBy: agentId,
+                    fromAgentId: handoff.fromAgentId,
+                });
+                let responseText = `✅ HANDOFF ACCEPTED: ${handoffId}\n\n`;
+                responseText += `From: ${handoff.fromAgentId}\n`;
+                responseText += `Task: ${handoff.taskDescription}\n`;
+                if (handoff.filesInScope?.length > 0) {
+                    responseText += `Files in scope: ${handoff.filesInScope.join(', ')}\n`;
+                }
+                responseText += `\nYou should now call rigour_agent_register to formally claim the scope.`;
+                result = {
+                    content: [{ type: "text", text: responseText }],
+                };
+                break;
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};