@rigour-labs/mcp 2.17.2 → 2.18.1

package/src/index.ts

@@ -299,6 +299,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"],
+                },
             }
         ],
     };
@@ -716,6 +873,403 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 break;
             }
 
+            case "rigour_run_supervised": {
+                const { command, maxRetries = 3, dryRun = false } = args as any;
+                const { execa } = await import("execa");
+
+                let iteration = 0;
+                let lastReport: Report | null = null;
+                const iterations: { iteration: number; status: string; failures: number }[] = [];
+
+                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: any) {
+                            // 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 as any;
+
+                // Load or create agent session
+                const sessionPath = path.join(cwd, '.rigour', 'agent-session.json');
+                let session = { agents: [] as any[], 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: any) => 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: string[] = [];
+                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 as any;
+
+                // Load checkpoint session
+                const checkpointPath = path.join(cwd, '.rigour', 'checkpoint-session.json');
+                let session = {
+                    sessionId: `chk-session-${Date.now()}`,
+                    startedAt: new Date().toISOString(),
+                    checkpoints: [] as any[],
+                    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: string[] = [];
+
+                // 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: any) => cp.qualityScore);
+                    const avgRecent = recentScores.reduce((a: number, b: number) => 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 as any)._shouldContinue = shouldContinue;
+
+                result = {
+                    content: [{ type: "text", text: responseText }],
+                };
+                break;
+            }
+
+            case "rigour_handoff": {
+                const { fromAgentId, toAgentId, taskDescription, filesInScope = [], context = '' } = args as any;
+
+                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 as any;
+
+                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: any) => 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: any) => a.agentId).join(', ')}`;
+                }
+
+                result = {
+                    content: [{ type: "text", text: responseText }],
+                };
+                break;
+            }
+
+            case "rigour_handoff_accept": {
+                const { handoffId, agentId } = args as any;
+
+                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: any) => 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: any) => 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}`);
         }