@rigour-labs/mcp 2.18.0 → 2.18.2

package/.claude-plugin/SKILL.md

@@ -0,0 +1,51 @@
+# Rigour Governance Skills
+
+Rigour provides meta-cognitive governance tools to ensure AI agents stay aligned with engineering standards, project context, and brand identity during long-running coworking tasks.
+
+## Skills
+
+### `rigour_checkpoint`
+Record a quality checkpoint during long-running agent execution. Use periodically (every 15-30 min) to enable drift detection and quality monitoring. Essential for coworking mode.
+
+**Parameters:**
+- `cwd` (string, required): Absolute path to the project root.
+- `progressPct` (number, required): Estimated progress percentage (0-100).
+- `summary` (string, required): Brief description of work done since last checkpoint.
+- `qualityScore` (number, required): Self-assessed quality score (0-100).
+- `filesChanged` (array of strings): List of files modified since last checkpoint.
+
+---
+
+### `rigour_agent_register`
+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.
+
+**Parameters:**
+- `cwd` (string, required): Absolute path to the project root.
+- `agentId` (string, required): Unique identifier for this agent (e.g., 'marketing-pro', 'sales-bot').
+- `taskScope` (array of strings, required): Glob patterns defining the files/directories this agent will work on.
+
+---
+
+### `rigour_check`
+Run all configured quality gates (Lint, Test, AST, etc.) on the project. Call this before completing a task to verify overall quality.
+
+**Parameters:**
+- `cwd` (string, required): Absolute path to the project root.
+
+---
+
+### `rigour_get_fix_packet`
+If gates fail, call this to retrieve a prioritized 'Fix Packet' containing detailed instructions on how to resolve the violations.
+
+**Parameters:**
+- `cwd` (string, required): Absolute path to the project root.
+
+---
+
+### `rigour_remember`
+Persist critical instructions or project-specific conventions that should be remembered across sessions.
+
+**Parameters:**
+- `cwd` (string, required): Absolute path to the project root.
+- `key` (string, required): Unique key for the memory.
+- `value` (string, required): The instruction or context to remember.

package/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+    "name": "Rigour Quality Governance",
+    "version": "2.14.0",
+    "description": "Meta-cognitive governance for AI agents. Monitor drift, manage agent teams, and enforce quality gates during long-running coworking tasks.",
+    "author": "Rigour Labs",
+    "capabilities": {
+        "mcp": {
+            "enabled": true
+        }
+    },
+    "entrypoint": "../dist/index.js",
+    "icon": "🛡️",
+    "categories": [
+        "Productivity",
+        "Developer Tools"
+    ]
+}

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

@@ -299,6 +299,137 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     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"],
+                },
             }
         ],
     };
@@ -774,6 +905,255 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 });
                 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 {};